projects / hashcat.git / blob
? search:


0f55a56fd44547b9e2593b75cead644301ca1c49
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Author......: Jens Steube <jens.steube@gmail.com>
3 * License.....: MIT
4 */
5
6 #include <common.h>
7 #include <shared.h>
8 #include <rp_kernel_on_cpu.h>
9 #include <getopt.h>
10
11 const char *PROGNAME = "oclHashcat";
12 const char *VERSION_TXT = "2.10";
13 const uint VERSION_BIN = 210;
14 const uint RESTORE_MIN = 210;
15
16 #define INCR_RULES 10000
17 #define INCR_SALTS 100000
18 #define INCR_MASKS 1000
19 #define INCR_POT 1000
20
21 #define USAGE 0
22 #define VERSION 0
23 #define QUIET 0
24 #define MARKOV_THRESHOLD 0
25 #define MARKOV_DISABLE 0
26 #define MARKOV_CLASSIC 0
27 #define BENCHMARK 0
28 #define BENCHMARK_MODE 1
29 #define RESTORE 0
30 #define RESTORE_TIMER 60
31 #define RESTORE_DISABLE 0
32 #define STATUS 0
33 #define STATUS_TIMER 10
34 #define STATUS_AUTOMAT 0
35 #define LOOPBACK 0
36 #define WEAK_HASH_THRESHOLD 100
37 #define SHOW 0
38 #define LEFT 0
39 #define USERNAME 0
40 #define REMOVE 0
41 #define REMOVE_TIMER 60
42 #define SKIP 0
43 #define LIMIT 0
44 #define KEYSPACE 0
45 #define POTFILE_DISABLE 0
46 #define DEBUG_MODE 0
47 #define RP_GEN 0
48 #define RP_GEN_FUNC_MIN 1
49 #define RP_GEN_FUNC_MAX 4
50 #define RP_GEN_SEED 0
51 #define RULE_BUF_L ":"
52 #define RULE_BUF_R ":"
53 #define FORCE 0
54 #define RUNTIME 0
55 #define HEX_CHARSET 0
56 #define HEX_SALT 0
57 #define HEX_WORDLIST 0
58 #define OUTFILE_FORMAT 3
59 #define OUTFILE_AUTOHEX 1
60 #define OUTFILE_CHECK_TIMER 5
61 #define ATTACK_MODE 0
62 #define HASH_MODE 0
63 #define SEGMENT_SIZE 32
64 #define INCREMENT 0
65 #define INCREMENT_MIN 1
66 #define INCREMENT_MAX PW_MAX
67 #define SEPARATOR ':'
68 #define BITMAP_MIN 16
69 #define BITMAP_MAX 24
70 #define GPU_TEMP_DISABLE 0
71 #define GPU_TEMP_ABORT 90
72 #define GPU_TEMP_RETAIN 80
73 #define WORKLOAD_PROFILE 2
74 #define KERNEL_ACCEL 0
75 #define KERNEL_LOOPS 0
76 #define KERNEL_RULES 1024
77 #define KERNEL_COMBS 1024
78 #define KERNEL_BFS 1024
79 #define KERNEL_THREADS 64
80 #define POWERTUNE_ENABLE 0
81 #define LOGFILE_DISABLE 0
82 #define SCRYPT_TMTO 0
83
84 #define WL_MODE_STDIN 1
85 #define WL_MODE_FILE 2
86 #define WL_MODE_MASK 3
87
88 #define HL_MODE_FILE 4
89 #define HL_MODE_ARG 5
90
91 #define HLFMT_HASHCAT 0
92 #define HLFMT_PWDUMP 1
93 #define HLFMT_PASSWD 2
94 #define HLFMT_SHADOW 3
95 #define HLFMT_DCC 4
96 #define HLFMT_DCC2 5
97 #define HLFMT_NETNTLM1 7
98 #define HLFMT_NETNTLM2 8
99 #define HLFMT_NSLDAP 9
100 #define HLFMT_NSLDAPS 10
101 #define HLFMTS_CNT 11
102
103 #define ATTACK_MODE_STRAIGHT 0
104 #define ATTACK_MODE_COMBI 1
105 #define ATTACK_MODE_TOGGLE 2
106 #define ATTACK_MODE_BF 3
107 #define ATTACK_MODE_PERM 4
108 #define ATTACK_MODE_TABLE 5
109 #define ATTACK_MODE_HYBRID1 6
110 #define ATTACK_MODE_HYBRID2 7
111 #define ATTACK_MODE_NONE 100
112
113 #define ATTACK_KERN_STRAIGHT 0
114 #define ATTACK_KERN_COMBI 1
115 #define ATTACK_KERN_BF 3
116 #define ATTACK_KERN_NONE 100
117
118 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
119 #define ATTACK_EXEC_INSIDE_KERNEL 11
120
121 #define COMBINATOR_MODE_BASE_LEFT 10001
122 #define COMBINATOR_MODE_BASE_RIGHT 10002
123
124 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
125 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
126
127 #define MAX_CUT_TRIES 4
128
129 #define MAX_DICTSTAT 10000
130
131 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 128
132
133 #define global_free(attr) \
134 { \
135 myfree ((void *) data.attr); \
136 \
137 data.attr = NULL; \
138 }
139
140 #define local_free(attr) \
141 { \
142 myfree ((void *) attr); \
143 \
144 attr = NULL; \
145 }
146
147 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
148 {
149 900,
150 0,
151 5100,
152 100,
153 1400,
154 10800,
155 1700,
156 5000,
157 10100,
158 6000,
159 6100,
160 6900,
161 11700,
162 11800,
163 400,
164 8900,
165 11900,
166 12000,
167 10900,
168 12100,
169 23,
170 2500,
171 5300,
172 5400,
173 5500,
174 5600,
175 7300,
176 7500,
177 8300,
178 11100,
179 11200,
180 11400,
181 121,
182 2611,
183 2711,
184 2811,
185 8400,
186 11,
187 2612,
188 7900,
189 21,
190 11000,
191 124,
192 10000,
193 3711,
194 7600,
195 12,
196 131,
197 132,
198 1731,
199 200,
200 300,
201 3100,
202 112,
203 12300,
204 8000,
205 141,
206 1441,
207 1600,
208 12600,
209 1421,
210 101,
211 111,
212 1711,
213 3000,
214 1000,
215 1100,
216 2100,
217 12800,
218 1500,
219 12400,
220 500,
221 3200,
222 7400,
223 1800,
224 122,
225 1722,
226 7100,
227 6300,
228 6700,
229 6400,
230 6500,
231 2400,
232 2410,
233 5700,
234 9200,
235 9300,
236 22,
237 501,
238 5800,
239 8100,
240 8500,
241 7200,
242 9900,
243 7700,
244 7800,
245 10300,
246 8600,
247 8700,
248 9100,
249 133,
250 11600,
251 12500,
252 6211,
253 6221,
254 6231,
255 6241,
256 8800,
257 12200,
258 9700,
259 9710,
260 9800,
261 9810,
262 9400,
263 9500,
264 9600,
265 10400,
266 10410,
267 10500,
268 10600,
269 10700,
270 9000,
271 5200,
272 6800,
273 6600,
274 8200,
275 11300,
276 12700
277 };
278
279 /**
280 * types
281 */
282
283 static void (*get_next_word_func) (char *, uint32_t, uint32_t *, uint32_t *);
284
285 /**
286 * globals
287 */
288
289 static unsigned int full01 = 0x01010101;
290 static unsigned int full80 = 0x80808080;
291
292 int SUPPRESS_OUTPUT = 0;
293
294 hc_thread_mutex_t mux_adl;
295 hc_thread_mutex_t mux_counter;
296 hc_thread_mutex_t mux_dispatcher;
297 hc_thread_mutex_t mux_display;
298
299 hc_global_data_t data;
300
301 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
302
303 const char *USAGE_MINI[] =
304 {
305 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
306 "",
307 "Try --help for more help.",
308 NULL
309 };
310
311 const char *USAGE_BIG[] =
312 {
313 "%s, advanced password recovery",
314 "",
315 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
316 "",
317 "=======",
318 "Options",
319 "=======",
320 "",
321 "* General:",
322 "",
323 " -m, --hash-type=NUM Hash-type, see references below",
324 " -a, --attack-mode=NUM Attack-mode, see references below",
325 " -V, --version Print version",
326 " -h, --help Print help",
327 " --quiet Suppress output",
328 "",
329 "* Benchmark:",
330 "",
331 " -b, --benchmark Run benchmark",
332 " --benchmark-mode=NUM Benchmark-mode, see references below",
333 "",
334 "* Misc:",
335 "",
336 " --hex-charset Assume charset is given in hex",
337 " --hex-salt Assume salt is given in hex",
338 " --hex-wordlist Assume words in wordlist is given in hex",
339 " --force Ignore warnings",
340 " --status Enable automatic update of the status-screen",
341 " --status-timer=NUM Seconds between status-screen update",
342 " --status-automat Display the status view in a machine readable format",
343 " --loopback Add new plains to induct directory",
344 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
345 "",
346 "* Markov:",
347 "",
348 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
349 " --markov-disable Disables markov-chains, emulates classic brute-force",
350 " --markov-classic Enables classic markov-chains, no per-position enhancement",
351 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
352 "",
353 "* Session:",
354 "",
355 " --runtime=NUM Abort session after NUM seconds of runtime",
356 " --session=STR Define specific session name",
357 " --restore Restore session from --session",
358 " --restore-disable Do not write restore file",
359 "",
360 "* Files:",
361 "",
362 " -o, --outfile=FILE Define outfile for recovered hash",
363 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
364 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
365 " --outfile-check-timer=NUM Seconds between outfile checks",
366 " -p, --separator=CHAR Separator char for hashlists and outfile",
367 " --show Show cracked passwords only",
368 " --left Show un-cracked passwords only",
369 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
370 " --remove Enable remove of hash once it is cracked",
371 " --remove-timer=NUM Update input hash file each NUM seconds",
372 " --potfile-disable Do not write potfile",
373 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
374 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
375 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
376 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
377 " --logfile-disable Disable the logfile",
378 " --truecrypt-keyfiles=FILE Keyfiles used, seperate with comma",
379 "",
380 "* Resources:",
381 "",
382 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
383 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
384 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
385 " --cpu-affinity=STR Locks to CPU devices, seperate with comma",
386 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
387 " --opencl-platform=NUM OpenCL platform to use, in case multiple platforms are present",
388 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
389 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
390 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
391 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
392 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
393 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
394 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
395 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
396 "",
397 "* Distributed:",
398 "",
399 " -s, --skip=NUM Skip number of words",
400 " -l, --limit=NUM Limit number of words",
401 " --keyspace Show keyspace base:mod values and quit",
402 "",
403 "* Rules:",
404 "",
405 " -j, --rule-left=RULE Single rule applied to each word from left dict",
406 " -k, --rule-right=RULE Single rule applied to each word from right dict",
407 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
408 " -g, --generate-rules=NUM Generate NUM random rules",
409 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
410 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
411 " --generate-rules-seed=NUM Force RNG seed to NUM",
412 "",
413 "* Custom charsets:",
414 "",
415 " -1, --custom-charset1=CS User-defined charsets",
416 " -2, --custom-charset2=CS Example:",
417 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
418 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
419 "",
420 "* Increment:",
421 "",
422 " -i, --increment Enable increment mode",
423 " --increment-min=NUM Start incrementing at NUM",
424 " --increment-max=NUM Stop incrementing at NUM",
425 "",
426 "==========",
427 "References",
428 "==========",
429 "",
430 "* Workload Profile:",
431 "",
432 " 1 = Reduced performance profile (low latency desktop)",
433 " 2 = Default performance profile",
434 " 3 = Tuned performance profile (high latency desktop)",
435 "",
436 "* Benchmark Settings:",
437 "",
438 " 0 = Manual Tuning",
439 " 1 = Performance Tuning, default",
440 "",
441 "* Outfile Formats:",
442 "",
443 " 1 = hash[:salt]",
444 " 2 = plain",
445 " 3 = hash[:salt]:plain",
446 " 4 = hex_plain",
447 " 5 = hash[:salt]:hex_plain",
448 " 6 = plain:hex_plain",
449 " 7 = hash[:salt]:plain:hex_plain",
450 " 8 = crackpos",
451 " 9 = hash[:salt]:crackpos",
452 " 10 = plain:crackpos",
453 " 11 = hash[:salt]:plain:crackpos",
454 " 12 = hex_plain:crackpos",
455 " 13 = hash[:salt]:hex_plain:crackpos",
456 " 14 = plain:hex_plain:crackpos",
457 " 15 = hash[:salt]:plain:hex_plain:crackpos",
458 "",
459 "* Debug mode output formats (for hybrid mode only, by using rules):",
460 "",
461 " 1 = save finding rule",
462 " 2 = save original word",
463 " 3 = save original word and finding rule",
464 " 4 = save original word, finding rule and modified plain",
465 "",
466 "* Built-in charsets:",
467 "",
468 " ?l = abcdefghijklmnopqrstuvwxyz",
469 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
470 " ?d = 0123456789",
471 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
472 " ?a = ?l?u?d?s",
473 " ?b = 0x00 - 0xff",
474 "",
475 "* Attack modes:",
476 "",
477 " 0 = Straight",
478 " 1 = Combination",
479 " 3 = Brute-force",
480 " 6 = Hybrid dict + mask",
481 " 7 = Hybrid mask + dict",
482 "",
483 "* Hash types:",
484 "",
485 "[[ Roll-your-own: Raw Hashes ]]",
486 "",
487 " 900 = MD4",
488 " 0 = MD5",
489 " 5100 = Half MD5",
490 " 100 = SHA1",
491 " 10800 = SHA-384",
492 " 1400 = SHA-256",
493 " 1700 = SHA-512",
494 " 5000 = SHA-3(Keccak)",
495 " 10100 = SipHash",
496 " 6000 = RipeMD160",
497 " 6100 = Whirlpool",
498 " 6900 = GOST R 34.11-94",
499 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
500 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
501 "",
502 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
503 "",
504 " 10 = md5($pass.$salt)",
505 " 20 = md5($salt.$pass)",
506 " 30 = md5(unicode($pass).$salt)",
507 " 40 = md5($salt.unicode($pass))",
508 " 3800 = md5($salt.$pass.$salt)",
509 " 3710 = md5($salt.md5($pass))",
510 " 2600 = md5(md5($pass)",
511 " 4300 = md5(strtoupper(md5($pass)))",
512 " 4400 = md5(sha1($pass))",
513 " 110 = sha1($pass.$salt)",
514 " 120 = sha1($salt.$pass)",
515 " 130 = sha1(unicode($pass).$salt)",
516 " 140 = sha1($salt.unicode($pass))",
517 " 4500 = sha1(sha1($pass)",
518 " 4700 = sha1(md5($pass))",
519 " 4900 = sha1($salt.$pass.$salt)",
520 " 1410 = sha256($pass.$salt)",
521 " 1420 = sha256($salt.$pass)",
522 " 1430 = sha256(unicode($pass).$salt)",
523 " 1440 = sha256($salt.unicode($pass))",
524 " 1710 = sha512($pass.$salt)",
525 " 1720 = sha512($salt.$pass)",
526 " 1730 = sha512(unicode($pass).$salt)",
527 " 1740 = sha512($salt.unicode($pass))",
528 "",
529 "[[ Roll-your-own: Authenticated Hashes ]]",
530 "",
531 " 50 = HMAC-MD5 (key = $pass)",
532 " 60 = HMAC-MD5 (key = $salt)",
533 " 150 = HMAC-SHA1 (key = $pass)",
534 " 160 = HMAC-SHA1 (key = $salt)",
535 " 1450 = HMAC-SHA256 (key = $pass)",
536 " 1460 = HMAC-SHA256 (key = $salt)",
537 " 1750 = HMAC-SHA512 (key = $pass)",
538 " 1760 = HMAC-SHA512 (key = $salt)",
539 "",
540 "[[ Generic KDF ]]",
541 "",
542 " 400 = phpass",
543 " 8900 = scrypt",
544 " 11900 = PBKDF2-HMAC-MD5",
545 " 12000 = PBKDF2-HMAC-SHA1",
546 " 10900 = PBKDF2-HMAC-SHA256",
547 " 12100 = PBKDF2-HMAC-SHA512",
548 "",
549 "[[ Network protocols, Challenge-Response ]]",
550 "",
551 " 23 = Skype",
552 " 2500 = WPA/WPA2",
553 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
554 " 5300 = IKE-PSK MD5",
555 " 5400 = IKE-PSK SHA1",
556 " 5500 = NetNTLMv1",
557 " 5500 = NetNTLMv1 + ESS",
558 " 5600 = NetNTLMv2",
559 " 7300 = IPMI2 RAKP HMAC-SHA1",
560 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
561 " 8300 = DNSSEC (NSEC3)",
562 " 10200 = Cram MD5",
563 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
564 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
565 " 11400 = SIP digest authentication (MD5)",
566 "",
567 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
568 "",
569 " 121 = SMF (Simple Machines Forum)",
570 " 400 = phpBB3",
571 " 2611 = vBulletin < v3.8.5",
572 " 2711 = vBulletin > v3.8.5",
573 " 2811 = MyBB",
574 " 2811 = IPB (Invison Power Board)",
575 " 8400 = WBB3 (Woltlab Burning Board)",
576 " 11 = Joomla < 2.5.18",
577 " 400 = Joomla > 2.5.18",
578 " 400 = Wordpress",
579 " 2612 = PHPS",
580 " 7900 = Drupal7",
581 " 21 = osCommerce",
582 " 21 = xt:Commerce",
583 " 11000 = PrestaShop",
584 " 124 = Django (SHA-1)",
585 " 10000 = Django (PBKDF2-SHA256)",
586 " 3711 = Mediawiki B type",
587 " 7600 = Redmine",
588 "",
589 "[[ Database Server ]]",
590 "",
591 " 12 = PostgreSQL",
592 " 131 = MSSQL(2000)",
593 " 132 = MSSQL(2005)",
594 " 1731 = MSSQL(2012)",
595 " 1731 = MSSQL(2014)",
596 " 200 = MySQL323",
597 " 300 = MySQL4.1/MySQL5",
598 " 3100 = Oracle H: Type (Oracle 7+)",
599 " 112 = Oracle S: Type (Oracle 11+)",
600 " 12300 = Oracle T: Type (Oracle 12+)",
601 " 8000 = Sybase ASE",
602 "",
603 "[[ HTTP, SMTP, LDAP Server ]]",
604 "",
605 " 141 = EPiServer 6.x < v4",
606 " 1441 = EPiServer 6.x > v4",
607 " 1600 = Apache $apr1$",
608 " 12600 = ColdFusion 10+",
609 " 1421 = hMailServer",
610 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
611 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
612 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
613 "",
614 "[[ Checksums ]]",
615 "",
616 " 11500 = CRC32",
617 "",
618 "[[ Operating-Systems ]]",
619 "",
620 " 3000 = LM",
621 " 1000 = NTLM",
622 " 1100 = Domain Cached Credentials (DCC), MS Cache",
623 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
624 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
625 " 1500 = descrypt, DES(Unix), Traditional DES",
626 " 12400 = BSDiCrypt, Extended DES",
627 " 500 = md5crypt $1$, MD5(Unix)",
628 " 3200 = bcrypt $2*$, Blowfish(Unix)",
629 " 7400 = sha256crypt $5$, SHA256(Unix)",
630 " 1800 = sha512crypt $6$, SHA512(Unix)",
631 " 122 = OSX v10.4",
632 " 122 = OSX v10.5",
633 " 122 = OSX v10.6",
634 " 1722 = OSX v10.7",
635 " 7100 = OSX v10.8",
636 " 7100 = OSX v10.9",
637 " 7100 = OSX v10.10",
638 " 6300 = AIX {smd5}",
639 " 6700 = AIX {ssha1}",
640 " 6400 = AIX {ssha256}",
641 " 6500 = AIX {ssha512}",
642 " 2400 = Cisco-PIX",
643 " 2410 = Cisco-ASA",
644 " 500 = Cisco-IOS $1$",
645 " 5700 = Cisco-IOS $4$",
646 " 9200 = Cisco-IOS $8$",
647 " 9300 = Cisco-IOS $9$",
648 " 22 = Juniper Netscreen/SSG (ScreenOS)",
649 " 501 = Juniper IVE",
650 " 5800 = Android PIN",
651 " 8100 = Citrix Netscaler",
652 " 8500 = RACF",
653 " 7200 = GRUB 2",
654 " 9900 = Radmin2",
655 "",
656 "[[ Enterprise Application Software (EAS) ]]",
657 "",
658 " 7700 = SAP CODVN B (BCODE)",
659 " 7800 = SAP CODVN F/G (PASSCODE)",
660 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
661 " 8600 = Lotus Notes/Domino 5",
662 " 8700 = Lotus Notes/Domino 6",
663 " 9100 = Lotus Notes/Domino 8",
664 " 133 = PeopleSoft",
665 "",
666 "[[ Archives ]]",
667 "",
668 " 11600 = 7-Zip",
669 " 12500 = RAR3-hp",
670 "",
671 "[[ Full-Disk encryptions (FDE) ]]",
672 "",
673 " 62XY = TrueCrypt 5.0+",
674 " X = 1 = PBKDF2-HMAC-RipeMD160",
675 " X = 2 = PBKDF2-HMAC-SHA512",
676 " X = 3 = PBKDF2-HMAC-Whirlpool",
677 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
678 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
679 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
680 " Y = 3 = XTS 1536 bit (Ciphers: All)",
681 " 8800 = Android FDE < v4.3",
682 " 12200 = eCryptfs",
683 "",
684 "[[ Documents ]]",
685 "",
686 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
687 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
688 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
689 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
690 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
691 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
692 " 9400 = MS Office 2007",
693 " 9500 = MS Office 2010",
694 " 9600 = MS Office 2013",
695 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
696 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
697 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
698 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
699 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
700 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
701 "",
702 "[[ Password Managers ]]",
703 "",
704 " 9000 = Password Safe v2",
705 " 5200 = Password Safe v3",
706 " 6800 = Lastpass",
707 " 6600 = 1Password, agilekeychain",
708 " 8200 = 1Password, cloudkeychain",
709 " 11300 = Bitcoin/Litecoin wallet.dat",
710 " 12700 = Blockchain, My Wallet",
711 "",
712 NULL
713 };
714
715 /**
716 * oclHashcat specific functions
717 */
718
719 void status_display_automat ()
720 {
721 FILE *out = stdout;
722
723 fprintf (out, "STATUS\t%u\t", data.devices_status);
724
725 /**
726 * speed new
727 */
728
729 fprintf (out, "SPEED\t");
730
731 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
732 {
733 hc_device_param_t *device_param = &data.devices_param[device_id];
734
735 uint64_t speed_cnt = 0;
736 float speed_ms = 0;
737
738 for (int i = 0; i < SPEED_CACHE; i++)
739 {
740 float rec_ms;
741
742 hc_timer_get (device_param->speed_rec[i], rec_ms);
743
744 if (rec_ms > SPEED_MAXAGE) continue;
745
746 speed_cnt += device_param->speed_cnt[i];
747 speed_ms += device_param->speed_ms[i];
748 }
749
750 speed_cnt /= SPEED_CACHE;
751 speed_ms /= SPEED_CACHE;
752
753 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
754 }
755
756 /**
757 * words_cur
758 */
759
760 uint64_t words_cur = get_lowest_words_done ();
761
762 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
763
764 /**
765 * counter
766 */
767
768 uint salts_left = data.salts_cnt - data.salts_done;
769
770 if (salts_left == 0) salts_left = 1;
771
772 uint64_t progress_total = data.words_cnt * salts_left;
773
774 uint64_t all_done = 0;
775 uint64_t all_rejected = 0;
776 uint64_t all_restored = 0;
777
778 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
779 {
780 if (salts_left > 1)
781 {
782 // otherwise the final cracked status shows 0/XXX progress
783
784 if (data.salts_shown[salt_pos] == 1) continue;
785 }
786
787 all_done += data.words_progress_done[salt_pos];
788 all_rejected += data.words_progress_rejected[salt_pos];
789 all_restored += data.words_progress_restored[salt_pos];
790 }
791
792 uint64_t progress_cur = all_restored + all_done + all_rejected;
793 uint64_t progress_end = progress_total;
794
795 uint64_t progress_skip = 0;
796
797 if (data.skip)
798 {
799 progress_skip = MIN (data.skip, data.words_base) * salts_left;
800
801 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
802 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
803 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
804 }
805
806 if (data.limit)
807 {
808 progress_end = MIN (data.limit, data.words_base) * salts_left;
809
810 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
811 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
812 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
813 }
814
815 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
816 uint64_t progress_end_relative_skip = progress_end - progress_skip;
817
818 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
819
820 /**
821 * cracks
822 */
823
824 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
825 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
826
827 /**
828 * temperature
829 */
830
831 if (data.gpu_temp_disable == 0)
832 {
833 fprintf (out, "TEMP\t");
834
835 hc_thread_mutex_lock (mux_adl);
836
837 for (uint i = 0; i < data.devices_cnt; i++)
838 {
839 int temp = hm_get_temperature_with_device_id (i);
840
841 fprintf (out, "%d\t", temp);
842 }
843
844 hc_thread_mutex_unlock (mux_adl);
845 }
846
847 #ifdef _WIN
848 fputc ('\r', out);
849 fputc ('\n', out);
850 #endif
851
852 #ifdef _POSIX
853 fputc ('\n', out);
854 #endif
855
856 fflush (out);
857 }
858
859 void status_display ()
860 {
861 if (data.devices_status == STATUS_INIT) return;
862 if (data.devices_status == STATUS_STARTING) return;
863 if (data.devices_status == STATUS_BYPASS) return;
864
865 if (data.status_automat == 1)
866 {
867 status_display_automat ();
868
869 return;
870 }
871
872 char tmp_buf[1000];
873
874 uint tmp_len = 0;
875
876 log_info ("Session.Name...: %s", data.session);
877
878 char *status_type = strstatus (data.devices_status);
879
880 uint hash_mode = data.hash_mode;
881
882 char *hash_type = strhashtype (hash_mode); // not a bug
883
884 log_info ("Status.........: %s", status_type);
885
886 /**
887 * show rules
888 */
889
890 if (data.rp_files_cnt)
891 {
892 uint i;
893
894 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
895 {
896 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
897 }
898
899 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
900
901 log_info ("Rules.Type.....: %s", tmp_buf);
902
903 tmp_len = 0;
904 }
905
906 if (data.rp_gen)
907 {
908 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
909
910 if (data.rp_gen_seed)
911 {
912 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
913 }
914 }
915
916 /**
917 * show input
918 */
919
920 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
921 {
922 if (data.wordlist_mode == WL_MODE_FILE)
923 {
924 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
925 }
926 else if (data.wordlist_mode == WL_MODE_STDIN)
927 {
928 log_info ("Input.Mode.....: Pipe");
929 }
930 }
931 else if (data.attack_mode == ATTACK_MODE_COMBI)
932 {
933 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
934 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
935 }
936 else if (data.attack_mode == ATTACK_MODE_BF)
937 {
938 char *mask = data.mask;
939
940 if (mask != NULL)
941 {
942 uint mask_len = data.css_cnt;
943
944 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
945
946 if (mask_len > 0)
947 {
948 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
949 {
950 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
951 {
952 mask_len -= data.salts_buf[0].salt_len;
953 }
954 }
955
956 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
957
958 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
959 }
960
961 if (data.maskcnt > 1)
962 {
963 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
964
965 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
966 }
967
968 log_info ("Input.Mode.....: %s", tmp_buf);
969 }
970
971 tmp_len = 0;
972 }
973 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
974 {
975 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
976 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
977 }
978 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
979 {
980 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
981 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
982 }
983
984 if (data.digests_cnt == 1)
985 {
986 if (data.hash_mode == 2500)
987 {
988 wpa_t *wpa = (wpa_t *) data.esalts_buf;
989
990 uint pke[25];
991
992 char *pke_ptr = (char *) pke;
993
994 for (uint i = 0; i < 25; i++)
995 {
996 pke[i] = byte_swap_32 (wpa->pke[i]);
997 }
998
999 char mac1[6];
1000 char mac2[6];
1001
1002 memcpy (mac1, pke_ptr + 23, 6);
1003 memcpy (mac2, pke_ptr + 29, 6);
1004
1005 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1006 (char *) data.salts_buf[0].salt_buf,
1007 mac1[0] & 0xff,
1008 mac1[1] & 0xff,
1009 mac1[2] & 0xff,
1010 mac1[3] & 0xff,
1011 mac1[4] & 0xff,
1012 mac1[5] & 0xff,
1013 mac2[0] & 0xff,
1014 mac2[1] & 0xff,
1015 mac2[2] & 0xff,
1016 mac2[3] & 0xff,
1017 mac2[4] & 0xff,
1018 mac2[5] & 0xff);
1019 }
1020 else if (data.hash_mode == 5200)
1021 {
1022 log_info ("Hash.Target....: File (%s)", data.hashfile);
1023 }
1024 else if (data.hash_mode == 9000)
1025 {
1026 log_info ("Hash.Target....: File (%s)", data.hashfile);
1027 }
1028 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1029 {
1030 log_info ("Hash.Target....: File (%s)", data.hashfile);
1031 }
1032 else
1033 {
1034 char out_buf[4096];
1035
1036 ascii_digest (out_buf, 0, 0);
1037
1038 // limit length
1039 if (strlen (out_buf) > 40)
1040 {
1041 out_buf[41] = '.';
1042 out_buf[42] = '.';
1043 out_buf[43] = '.';
1044 out_buf[44] = 0;
1045 }
1046
1047 log_info ("Hash.Target....: %s", out_buf);
1048 }
1049 }
1050 else
1051 {
1052 if (data.hash_mode == 3000)
1053 {
1054 char out_buf1[4096];
1055 char out_buf2[4096];
1056
1057 ascii_digest (out_buf1, 0, 0);
1058 ascii_digest (out_buf2, 0, 1);
1059
1060 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1061 }
1062 else
1063 {
1064 log_info ("Hash.Target....: File (%s)", data.hashfile);
1065 }
1066 }
1067
1068 log_info ("Hash.Type......: %s", hash_type);
1069
1070 /**
1071 * speed new
1072 */
1073
1074 uint64_t speed_cnt[DEVICES_MAX];
1075 float speed_ms[DEVICES_MAX];
1076
1077 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1078 {
1079 hc_device_param_t *device_param = &data.devices_param[device_id];
1080
1081 // we need to clear values (set to 0) because in case the device does
1082 // not get new candidates it idles around but speed display would
1083 // show it as working.
1084 // if we instantly set it to 0 after reading it happens that the
1085 // speed can be shown as zero if the users refreshs to fast.
1086 // therefore, we add a timestamp when a stat was recorded and if its
1087 // to old we will not use it
1088
1089 speed_cnt[device_id] = 0;
1090 speed_ms[device_id] = 0;
1091
1092 for (int i = 0; i < SPEED_CACHE; i++)
1093 {
1094 float rec_ms;
1095
1096 hc_timer_get (device_param->speed_rec[i], rec_ms);
1097
1098 if (rec_ms > SPEED_MAXAGE) continue;
1099
1100 speed_cnt[device_id] += device_param->speed_cnt[i];
1101 speed_ms[device_id] += device_param->speed_ms[i];
1102 }
1103
1104 speed_cnt[device_id] /= SPEED_CACHE;
1105 speed_ms[device_id] /= SPEED_CACHE;
1106 }
1107
1108 float hashes_all_ms = 0;
1109
1110 float hashes_dev_ms[DEVICES_MAX];
1111
1112 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1113 {
1114 hashes_dev_ms[device_id] = 0;
1115
1116 if (speed_ms[device_id])
1117 {
1118 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1119
1120 hashes_all_ms += hashes_dev_ms[device_id];
1121 }
1122 }
1123
1124 /**
1125 * timers
1126 */
1127
1128 float ms_running = 0;
1129
1130 hc_timer_get (data.timer_running, ms_running);
1131
1132 float ms_paused = data.ms_paused;
1133
1134 if (data.devices_status == STATUS_PAUSED)
1135 {
1136 float ms_paused_tmp = 0;
1137
1138 hc_timer_get (data.timer_paused, ms_paused_tmp);
1139
1140 ms_paused += ms_paused_tmp;
1141 }
1142
1143 #ifdef WIN
1144
1145 __time64_t sec_run = ms_running / 1000;
1146
1147 #else
1148
1149 time_t sec_run = ms_running / 1000;
1150
1151 #endif
1152
1153 if (sec_run)
1154 {
1155 char display_run[32];
1156
1157 struct tm tm_run;
1158
1159 struct tm *tmp;
1160
1161 #ifdef WIN
1162
1163 tmp = _gmtime64 (&sec_run);
1164
1165 #else
1166
1167 tmp = gmtime (&sec_run);
1168
1169 #endif
1170
1171 if (tmp != NULL)
1172 {
1173 memcpy (&tm_run, tmp, sizeof (struct tm));
1174
1175 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1176
1177 char *start = ctime (&data.proc_start);
1178
1179 size_t start_len = strlen (start);
1180
1181 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1182 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1183
1184 log_info ("Time.Started...: %s (%s)", start, display_run);
1185 }
1186 }
1187 else
1188 {
1189 log_info ("Time.Started...: 0 secs");
1190 }
1191
1192 /**
1193 * counters
1194 */
1195
1196 uint salts_left = data.salts_cnt - data.salts_done;
1197
1198 if (salts_left == 0) salts_left = 1;
1199
1200 uint64_t progress_total = data.words_cnt * salts_left;
1201
1202 uint64_t all_done = 0;
1203 uint64_t all_rejected = 0;
1204 uint64_t all_restored = 0;
1205
1206 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1207 {
1208 if (salts_left > 1)
1209 {
1210 // otherwise the final cracked status shows 0/XXX progress
1211
1212 if (data.salts_shown[salt_pos] == 1) continue;
1213 }
1214
1215 all_done += data.words_progress_done[salt_pos];
1216 all_rejected += data.words_progress_rejected[salt_pos];
1217 all_restored += data.words_progress_restored[salt_pos];
1218 }
1219
1220 uint64_t progress_cur = all_restored + all_done + all_rejected;
1221 uint64_t progress_end = progress_total;
1222
1223 uint64_t progress_skip = 0;
1224
1225 if (data.skip)
1226 {
1227 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1228
1229 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1230 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1231 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1232 }
1233
1234 if (data.limit)
1235 {
1236 progress_end = MIN (data.limit, data.words_base) * salts_left;
1237
1238 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1239 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1240 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1241 }
1242
1243 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
1244 uint64_t progress_end_relative_skip = progress_end - progress_skip;
1245
1246 float speed_ms_real = ms_running - ms_paused;
1247 uint64_t speed_plains_real = all_done;
1248
1249 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1250 {
1251 if (data.devices_status != STATUS_CRACKED)
1252 {
1253 uint64_t words_per_ms = 0;
1254
1255 if (speed_plains_real && speed_ms_real)
1256 {
1257 words_per_ms = speed_plains_real / speed_ms_real;
1258 }
1259
1260 #ifdef WIN
1261 __time64_t sec_etc = 0;
1262 #else
1263 time_t sec_etc = 0;
1264 #endif
1265
1266 if (words_per_ms)
1267 {
1268 uint64_t progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1269
1270 uint64_t ms_left = progress_left_relative_skip / words_per_ms;
1271
1272 sec_etc = ms_left / 1000;
1273 }
1274
1275 if (sec_etc == 0)
1276 {
1277 log_info ("Time.Estimated.: 0 secs");
1278 }
1279 else if ((uint64_t) sec_etc > ETC_MAX)
1280 {
1281 log_info ("Time.Estimated.: > 10 Years");
1282 }
1283 else
1284 {
1285 char display_etc[32];
1286
1287 struct tm tm_etc;
1288
1289 struct tm *tmp;
1290
1291 #ifdef WIN
1292
1293 tmp = _gmtime64 (&sec_etc);
1294
1295 #else
1296
1297 tmp = gmtime (&sec_etc);
1298
1299 #endif
1300
1301 if (tmp != NULL)
1302 {
1303 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1304
1305 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1306
1307 time_t now;
1308
1309 time (&now);
1310
1311 now += sec_etc;
1312
1313 char *etc = ctime (&now);
1314
1315 size_t etc_len = strlen (etc);
1316
1317 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1318 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1319
1320 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1321 }
1322 }
1323 }
1324 }
1325
1326 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1327 {
1328 char display_dev_cur[16];
1329
1330 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1331
1332 strncpy (display_dev_cur, "0.00", 4);
1333
1334 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1335
1336 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1337 }
1338
1339 char display_all_cur[16];
1340
1341 memset (display_all_cur, 0, sizeof (display_all_cur));
1342
1343 strncpy (display_all_cur, "0.00", 4);
1344
1345 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1346
1347 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1348
1349 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1350 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1351
1352 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1353
1354 // crack-per-time
1355
1356 if (data.digests_cnt > 100)
1357 {
1358 time_t now = time (NULL);
1359
1360 int cpt_cur_min = 0;
1361 int cpt_cur_hour = 0;
1362 int cpt_cur_day = 0;
1363
1364 for (int i = 0; i < CPT_BUF; i++)
1365 {
1366 const uint cracked = data.cpt_buf[i].cracked;
1367 const time_t timestamp = data.cpt_buf[i].timestamp;
1368
1369 if ((timestamp + 60) > now)
1370 {
1371 cpt_cur_min += cracked;
1372 }
1373
1374 if ((timestamp + 3600) > now)
1375 {
1376 cpt_cur_hour += cracked;
1377 }
1378
1379 if ((timestamp + 86400) > now)
1380 {
1381 cpt_cur_day += cracked;
1382 }
1383 }
1384
1385 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1386 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1387 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1388
1389 if ((data.cpt_start + 86400) < now)
1390 {
1391 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1392 cpt_cur_min,
1393 cpt_cur_hour,
1394 cpt_cur_day,
1395 cpt_avg_min,
1396 cpt_avg_hour,
1397 cpt_avg_day);
1398 }
1399 else if ((data.cpt_start + 3600) < now)
1400 {
1401 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1402 cpt_cur_min,
1403 cpt_cur_hour,
1404 cpt_avg_min,
1405 cpt_avg_hour,
1406 cpt_avg_day);
1407 }
1408 else if ((data.cpt_start + 60) < now)
1409 {
1410 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1411 cpt_cur_min,
1412 cpt_avg_min,
1413 cpt_avg_hour,
1414 cpt_avg_day);
1415 }
1416 else
1417 {
1418 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1419 cpt_avg_min,
1420 cpt_avg_hour,
1421 cpt_avg_day);
1422 }
1423 }
1424
1425 // Restore point
1426
1427 uint64_t restore_point = get_lowest_words_done ();
1428
1429 uint64_t restore_total = data.words_base;
1430
1431 float percent_restore = 0;
1432
1433 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1434
1435 if (progress_end_relative_skip)
1436 {
1437 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1438 {
1439 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1440 float percent_rejected = 0.0;
1441
1442 if (progress_cur)
1443 {
1444 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1445 }
1446
1447 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1448 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1449
1450 if (data.restore_disable == 0)
1451 {
1452 if (percent_finished != 1)
1453 {
1454 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1455 }
1456 }
1457 }
1458 }
1459 else
1460 {
1461 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1462 {
1463 log_info ("Progress.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1464 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1465
1466 if (data.restore_disable == 0)
1467 {
1468 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1469 }
1470 }
1471 else
1472 {
1473 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1474 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1475
1476 // --restore not allowed if stdin is used -- really? why?
1477
1478 //if (data.restore_disable == 0)
1479 //{
1480 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1481 //}
1482 }
1483 }
1484
1485 if (data.gpu_temp_disable == 0)
1486 {
1487 hc_thread_mutex_lock (mux_adl);
1488
1489 for (uint i = 0; i < data.devices_cnt; i++)
1490 {
1491 if (data.hm_device[i].fan_supported == 1)
1492 {
1493 const int temperature = hm_get_temperature_with_device_id (i);
1494 const int utilization = hm_get_utilization_with_device_id (i);
1495 const int fanspeed = hm_get_fanspeed_with_device_id (i);
1496
1497 if (data.vendor_id == VENDOR_ID_AMD)
1498 {
1499 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1500 }
1501
1502 if (data.vendor_id == VENDOR_ID_NV)
1503 {
1504 #ifdef LINUX
1505 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1506 #else
1507 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2drpm Fan", i + 1, utilization, temperature, fanspeed);
1508 #endif
1509 }
1510 }
1511 else
1512 {
1513 const int temperature = hm_get_temperature_with_device_id (i);
1514 const int utilization = hm_get_utilization_with_device_id (i);
1515
1516 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, N/A Fan", i + 1, utilization, temperature);
1517 }
1518 }
1519
1520 hc_thread_mutex_unlock (mux_adl);
1521 }
1522 }
1523
1524 static void status_benchmark ()
1525 {
1526 if (data.devices_status == STATUS_INIT) return;
1527 if (data.devices_status == STATUS_STARTING) return;
1528
1529 if (data.words_cnt == 0) return;
1530
1531 uint64_t speed_cnt[DEVICES_MAX];
1532 float speed_ms[DEVICES_MAX];
1533
1534 uint device_id;
1535
1536 for (device_id = 0; device_id < data.devices_cnt; device_id++)
1537 {
1538 hc_device_param_t *device_param = &data.devices_param[device_id];
1539
1540 speed_cnt[device_id] = 0;
1541 speed_ms[device_id] = 0;
1542
1543 for (int i = 0; i < SPEED_CACHE; i++)
1544 {
1545 speed_cnt[device_id] += device_param->speed_cnt[i];
1546 speed_ms[device_id] += device_param->speed_ms[i];
1547 }
1548
1549 speed_cnt[device_id] /= SPEED_CACHE;
1550 speed_ms[device_id] /= SPEED_CACHE;
1551 }
1552
1553 float hashes_all_ms = 0;
1554
1555 float hashes_dev_ms[DEVICES_MAX];
1556
1557 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1558 {
1559 hashes_dev_ms[device_id] = 0;
1560
1561 if (speed_ms[device_id])
1562 {
1563 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1564
1565 hashes_all_ms += hashes_dev_ms[device_id];
1566 }
1567 }
1568
1569 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1570 {
1571 char display_dev_cur[16];
1572
1573 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1574
1575 strncpy (display_dev_cur, "0.00", 4);
1576
1577 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1578
1579 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1580 }
1581
1582 char display_all_cur[16];
1583
1584 memset (display_all_cur, 0, sizeof (display_all_cur));
1585
1586 strncpy (display_all_cur, "0.00", 4);
1587
1588 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1589
1590 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1591 }
1592
1593 /**
1594 * oclHashcat -only- functions
1595 */
1596
1597 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1598 {
1599 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1600 {
1601 if (attack_kern == ATTACK_KERN_STRAIGHT)
1602 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1603 else if (attack_kern == ATTACK_KERN_COMBI)
1604 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1605 else if (attack_kern == ATTACK_KERN_BF)
1606 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1607 }
1608 else
1609 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1610 }
1611
1612 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1613 {
1614 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1615 {
1616 if (attack_kern == ATTACK_KERN_STRAIGHT)
1617 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a0.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1618 else if (attack_kern == ATTACK_KERN_COMBI)
1619 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a1.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1620 else if (attack_kern == ATTACK_KERN_BF)
1621 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a3.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1622 }
1623 else
1624 {
1625 snprintf (cached_file, 255, "%s/kernels/%d/m%05d.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1626 }
1627 }
1628
1629 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1630 {
1631 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1632 {
1633 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1634 }
1635 else
1636 {
1637 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1638 }
1639 }
1640
1641 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1642 {
1643 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1644 {
1645 snprintf (cached_file, 255, "%s/kernels/%d/markov_be.%s.kernel", profile_dir, vendor_id, device_name_chksum);
1646 }
1647 else
1648 {
1649 snprintf (cached_file, 255, "%s/kernels/%d/markov_le.%s.kernel", profile_dir, vendor_id, device_name_chksum);
1650 }
1651 }
1652
1653 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1654 {
1655 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1656 }
1657
1658 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1659 {
1660 snprintf (cached_file, 255, "%s/kernels/%d/amp_a%d.%s.kernel", profile_dir, vendor_id, attack_kern, device_name_chksum);
1661 }
1662
1663 static uint convert_from_hex (char *line_buf, const uint line_len)
1664 {
1665 if (line_len & 1) return (line_len); // not in hex
1666
1667 if (data.hex_wordlist == 1)
1668 {
1669 uint i;
1670 uint j;
1671
1672 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1673 {
1674 line_buf[i] = hex_to_char (&line_buf[j]);
1675 }
1676
1677 memset (line_buf + i, 0, line_len - i);
1678
1679 return (i);
1680 }
1681 else if (line_len >= 6) // $HEX[] = 6
1682 {
1683 if (line_buf[0] != '$') return (line_len);
1684 if (line_buf[1] != 'H') return (line_len);
1685 if (line_buf[2] != 'E') return (line_len);
1686 if (line_buf[3] != 'X') return (line_len);
1687 if (line_buf[4] != '[') return (line_len);
1688 if (line_buf[line_len - 1] != ']') return (line_len);
1689
1690 uint i;
1691 uint j;
1692
1693 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1694 {
1695 line_buf[i] = hex_to_char (&line_buf[j]);
1696 }
1697
1698 memset (line_buf + i, 0, line_len - i);
1699
1700 return (i);
1701 }
1702
1703 return (line_len);
1704 }
1705
1706 static uint count_lines (FILE *fd)
1707 {
1708 uint cnt = 0;
1709
1710 char *buf = (char *) mymalloc (BUFSIZ);
1711
1712 size_t nread_tmp = 0;
1713
1714 char *ptr = buf;
1715
1716 while (!feof (fd))
1717 {
1718 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1719 nread_tmp = nread;
1720
1721 if (nread < 1) continue;
1722
1723 ptr = buf;
1724
1725 do
1726 {
1727 if (*ptr++ == '\n') cnt++;
1728
1729 } while (nread--);
1730 }
1731
1732 // special case (if last line did not contain a newline char ... at the very end of the file)
1733
1734 if (nread_tmp > 3)
1735 {
1736 ptr -= 2;
1737
1738 if (*ptr != '\n')
1739 {
1740 ptr--;
1741
1742 if (*ptr != '\n') // needed ? different on windows systems?
1743 {
1744 cnt++;
1745 }
1746 }
1747 }
1748
1749 myfree (buf);
1750
1751 return cnt;
1752 }
1753
1754 static void clear_prompt ()
1755 {
1756 fputc ('\r', stdout);
1757
1758 for (size_t i = 0; i < strlen (PROMPT); i++)
1759 {
1760 fputc (' ', stdout);
1761 }
1762
1763 fputc ('\r', stdout);
1764
1765 fflush (stdout);
1766 }
1767
1768 static void gidd_to_pw_t (hc_device_param_t *device_param, const uint64_t gidd, pw_t *pw)
1769 {
1770 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1771 }
1772
1773 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1774 {
1775 char *outfile = data.outfile;
1776 uint quiet = data.quiet;
1777 FILE *pot_fp = data.pot_fp;
1778 uint loopback = data.loopback;
1779 uint debug_mode = data.debug_mode;
1780 char *debug_file = data.debug_file;
1781
1782 char debug_rule_buf[BLOCK_SIZE];
1783 int debug_rule_len = 0; // -1 error
1784 uint debug_plain_len = 0;
1785
1786 unsigned char debug_plain_ptr[BLOCK_SIZE];
1787
1788 // hash
1789
1790 char out_buf[4096]; memset (out_buf, 0, sizeof (out_buf));
1791
1792 ascii_digest (out_buf, salt_pos, digest_pos);
1793
1794 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1795
1796 // plain
1797
1798 plain_t plain;
1799
1800 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1801
1802 uint gidvid = plain.gidvid;
1803 uint il_pos = plain.il_pos;
1804
1805 uint64_t crackpos = device_param->words_off;
1806
1807 uint plain_buf[16];
1808
1809 unsigned char *plain_ptr = (unsigned char *) plain_buf;
1810 unsigned int plain_len = 0;
1811
1812 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1813 {
1814 uint64_t gidd = gidvid;
1815 uint64_t gidm = 0;
1816
1817 pw_t pw;
1818
1819 gidd_to_pw_t (device_param, gidd, &pw);
1820
1821 for (int i = 0, j = gidm; i < 16; i++, j++)
1822 {
1823 plain_buf[i] = pw.hi1[0][j];
1824 }
1825
1826 plain_len = pw.pw_len;
1827
1828 const uint off = device_param->innerloop_pos + il_pos;
1829
1830 if (debug_mode > 0)
1831 {
1832 debug_rule_len = 0;
1833
1834 // save rule
1835 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1836 {
1837 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1838
1839 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1840 }
1841
1842 // save plain
1843 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1844 {
1845 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1846
1847 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1848
1849 debug_plain_len = plain_len;
1850 }
1851 }
1852
1853 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1854
1855 crackpos += gidvid;
1856 crackpos *= data.kernel_rules_cnt;
1857 crackpos += device_param->innerloop_pos + il_pos;
1858
1859 if (plain_len > data.pw_max) plain_len = data.pw_max;
1860 }
1861 else if (data.attack_mode == ATTACK_MODE_COMBI)
1862 {
1863 uint64_t gidd = gidvid;
1864 uint64_t gidm = 0;
1865
1866 pw_t pw;
1867
1868 gidd_to_pw_t (device_param, gidd, &pw);
1869
1870 for (int i = 0, j = gidm; i < 16; i++, j++)
1871 {
1872 plain_buf[i] = pw.hi1[0][j];
1873 }
1874
1875 plain_len = pw.pw_len;
1876
1877 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1878 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1879
1880 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1881 {
1882 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1883 }
1884 else
1885 {
1886 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1887
1888 memcpy (plain_ptr, comb_buf, comb_len);
1889 }
1890
1891 plain_len += comb_len;
1892
1893 crackpos += gidvid;
1894 crackpos *= data.combs_cnt;
1895 crackpos += device_param->innerloop_pos + il_pos;
1896
1897 if (data.pw_max != PW_DICTMAX1)
1898 {
1899 if (plain_len > data.pw_max) plain_len = data.pw_max;
1900 }
1901 }
1902 else if (data.attack_mode == ATTACK_MODE_BF)
1903 {
1904 uint64_t l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1905 uint64_t r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1906
1907 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1908 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1909
1910 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1911 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1912
1913 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1914 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1915
1916 plain_len = data.css_cnt;
1917
1918 crackpos += gidvid;
1919 crackpos *= data.bfs_cnt;
1920 crackpos += device_param->innerloop_pos + il_pos;
1921 }
1922 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1923 {
1924 uint64_t gidd = gidvid;
1925 uint64_t gidm = 0;
1926
1927 pw_t pw;
1928
1929 gidd_to_pw_t (device_param, gidd, &pw);
1930
1931 for (int i = 0, j = gidm; i < 16; i++, j++)
1932 {
1933 plain_buf[i] = pw.hi1[0][j];
1934 }
1935
1936 plain_len = pw.pw_len;
1937
1938 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1939
1940 uint start = 0;
1941 uint stop = device_param->kernel_params_mp_buf32[4];
1942
1943 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1944
1945 plain_len += start + stop;
1946
1947 crackpos += gidvid;
1948 crackpos *= data.combs_cnt;
1949 crackpos += device_param->innerloop_pos + il_pos;
1950
1951 if (data.pw_max != PW_DICTMAX1)
1952 {
1953 if (plain_len > data.pw_max) plain_len = data.pw_max;
1954 }
1955 }
1956 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1957 {
1958 uint64_t gidd = gidvid;
1959 uint64_t gidm = 0;
1960
1961 pw_t pw;
1962
1963 gidd_to_pw_t (device_param, gidd, &pw);
1964
1965 for (int i = 0, j = gidm; i < 16; i++, j++)
1966 {
1967 plain_buf[i] = pw.hi1[0][j];
1968 }
1969
1970 plain_len = pw.pw_len;
1971
1972 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1973
1974 uint start = 0;
1975 uint stop = device_param->kernel_params_mp_buf32[4];
1976
1977 memmove (plain_ptr + stop, plain_ptr, plain_len);
1978
1979 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
1980
1981 plain_len += start + stop;
1982
1983 crackpos += gidvid;
1984 crackpos *= data.combs_cnt;
1985 crackpos += device_param->innerloop_pos + il_pos;
1986
1987 if (data.pw_max != PW_DICTMAX1)
1988 {
1989 if (plain_len > data.pw_max) plain_len = data.pw_max;
1990 }
1991 }
1992
1993 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
1994 {
1995 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1996 {
1997 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1998 {
1999 plain_len = plain_len - data.salts_buf[0].salt_len;
2000 }
2001 }
2002
2003 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2004 {
2005 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2006 {
2007 plain_ptr[j] = plain_ptr[i];
2008 }
2009
2010 plain_len = plain_len / 2;
2011 }
2012 }
2013
2014 // if enabled, update also the potfile
2015
2016 if (pot_fp)
2017 {
2018 fprintf (pot_fp, "%s:", out_buf);
2019
2020 format_plain (pot_fp, plain_ptr, plain_len, 1);
2021
2022 fputc ('\n', pot_fp);
2023
2024 fflush (pot_fp);
2025 }
2026
2027 // outfile
2028
2029 FILE *out_fp = NULL;
2030
2031 if (outfile != NULL)
2032 {
2033 if ((out_fp = fopen (outfile, "ab")) == NULL)
2034 {
2035 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2036
2037 out_fp = stdout;
2038 }
2039 }
2040 else
2041 {
2042 out_fp = stdout;
2043
2044 if (quiet == 0) clear_prompt ();
2045 }
2046
2047 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2048
2049 if (outfile != NULL)
2050 {
2051 if (out_fp != stdout)
2052 {
2053 fclose (out_fp);
2054 }
2055 }
2056 else
2057 {
2058 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2059 {
2060 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2061 {
2062 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2063 if (quiet == 0) fflush (stdout);
2064 }
2065 }
2066 }
2067
2068 // loopback
2069
2070 if (loopback)
2071 {
2072 char *loopback_file = data.loopback_file;
2073
2074 FILE *fb_fp = NULL;
2075
2076 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2077 {
2078 format_plain (fb_fp, plain_ptr, plain_len, 1);
2079
2080 fputc ('\n', fb_fp);
2081
2082 fclose (fb_fp);
2083 }
2084 }
2085
2086 // (rule) debug mode
2087
2088 // the next check implies that:
2089 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2090 // - debug_mode > 0
2091
2092 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2093 {
2094 if (debug_rule_len < 0) debug_rule_len = 0;
2095
2096 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2097
2098 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2099
2100 if ((quiet == 0) && (debug_file == NULL))
2101 {
2102 fprintf (stdout, "%s", PROMPT);
2103 fflush (stdout);
2104 }
2105 }
2106 }
2107
2108 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2109 {
2110 salt_t *salt_buf = &data.salts_buf[salt_pos];
2111
2112 int found = 0;
2113
2114 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2115
2116 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2117
2118 if (found == 1)
2119 {
2120 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2121
2122 log_info_nn ("");
2123
2124 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2125
2126 uint cpt_cracked = 0;
2127
2128 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2129 {
2130 uint idx = salt_buf->digests_offset + digest_pos;
2131
2132 if (data.digests_shown_tmp[idx] == 0) continue;
2133
2134 if (data.digests_shown[idx] == 1) continue;
2135
2136 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2137 {
2138 data.digests_shown[idx] = 1;
2139
2140 data.digests_done++;
2141
2142 cpt_cracked++;
2143
2144 salt_buf->digests_done++;
2145
2146 if (salt_buf->digests_done == salt_buf->digests_cnt)
2147 {
2148 data.salts_shown[salt_pos] = 1;
2149
2150 data.salts_done++;
2151 }
2152 }
2153
2154 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2155
2156 check_hash (device_param, salt_pos, digest_pos);
2157 }
2158
2159 if (cpt_cracked > 0)
2160 {
2161 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2162 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2163
2164 data.cpt_pos++;
2165
2166 data.cpt_total += cpt_cracked;
2167
2168 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2169 }
2170
2171 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2172 {
2173 // we need to reset cracked state on the device
2174 // otherwise host thinks again and again the hash was cracked
2175 // and returns invalid password each time
2176
2177 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2178
2179 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2180 }
2181
2182 memset (device_param->result, 0, device_param->size_results);
2183
2184 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2185 }
2186 }
2187
2188 static void save_hash ()
2189 {
2190 char *hashfile = data.hashfile;
2191
2192 char new_hashfile[256];
2193 char old_hashfile[256];
2194
2195 memset (new_hashfile, 0, sizeof (new_hashfile));
2196 memset (old_hashfile, 0, sizeof (old_hashfile));
2197
2198 snprintf (new_hashfile, 255, "%s.new", hashfile);
2199 snprintf (old_hashfile, 255, "%s.old", hashfile);
2200
2201 unlink (new_hashfile);
2202
2203 char separator = data.separator;
2204
2205 FILE *fp = fopen (new_hashfile, "wb");
2206
2207 if (fp == NULL)
2208 {
2209 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2210
2211 exit (-1);
2212 }
2213
2214 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2215 {
2216 if (data.salts_shown[salt_pos] == 1) continue;
2217
2218 salt_t *salt_buf = &data.salts_buf[salt_pos];
2219
2220 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2221 {
2222 uint idx = salt_buf->digests_offset + digest_pos;
2223
2224 if (data.digests_shown[idx] == 1) continue;
2225
2226 if (data.hash_mode != 2500)
2227 {
2228 char out_buf[4096];
2229
2230 memset (out_buf, 0, sizeof (out_buf));
2231
2232 if (data.username == 1)
2233 {
2234 user_t *user = data.hash_info[idx]->user;
2235
2236 uint i;
2237
2238 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2239
2240 fputc (separator, fp);
2241 }
2242
2243 ascii_digest (out_buf, salt_pos, digest_pos);
2244
2245 fputs (out_buf, fp);
2246
2247 log_out (fp, "");
2248 }
2249 else
2250 {
2251 hccap_t hccap;
2252
2253 to_hccap_t (&hccap, salt_pos, digest_pos);
2254
2255 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2256 }
2257 }
2258 }
2259
2260 fflush (fp);
2261
2262 fclose (fp);
2263
2264 unlink (old_hashfile);
2265
2266 if (rename (hashfile, old_hashfile) != 0)
2267 {
2268 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2269
2270 exit (-1);
2271 }
2272
2273 unlink (hashfile);
2274
2275 if (rename (new_hashfile, hashfile) != 0)
2276 {
2277 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2278
2279 exit (-1);
2280 }
2281
2282 unlink (old_hashfile);
2283 }
2284
2285 static float find_kernel_blocks_div (const uint64_t total_left, const uint kernel_blocks_all)
2286 {
2287 // function called only in case kernel_blocks_all > words_left)
2288
2289 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2290
2291 kernel_blocks_div += kernel_blocks_div / 100;
2292
2293 uint32_t kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2294
2295 while (kernel_blocks_new < total_left)
2296 {
2297 kernel_blocks_div += kernel_blocks_div / 100;
2298
2299 kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2300 }
2301
2302 if (data.quiet == 0)
2303 {
2304 clear_prompt ();
2305
2306 log_info ("");
2307
2308 log_info ("INFO: approaching final keyspace, workload adjusted");
2309
2310 log_info ("");
2311
2312 fprintf (stdout, "%s", PROMPT);
2313
2314 fflush (stdout);
2315 }
2316
2317 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2318
2319 return kernel_blocks_div;
2320 }
2321
2322 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2323 {
2324 uint num_elements = num;
2325
2326 device_param->kernel_params_buf32[30] = data.combs_mode;
2327 device_param->kernel_params_buf32[31] = num;
2328
2329 uint kernel_threads = device_param->kernel_threads;
2330
2331 while (num_elements % kernel_threads) num_elements++;
2332
2333 cl_kernel kernel = NULL;
2334
2335 switch (kern_run)
2336 {
2337 case KERN_RUN_1: kernel = device_param->kernel1; break;
2338 case KERN_RUN_12: kernel = device_param->kernel12; break;
2339 case KERN_RUN_2: kernel = device_param->kernel2; break;
2340 case KERN_RUN_23: kernel = device_param->kernel23; break;
2341 case KERN_RUN_3: kernel = device_param->kernel3; break;
2342 }
2343
2344 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2345 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2346 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2347 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2348 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2349 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2350 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2351 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2352 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2353 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2354 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2355
2356 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2357 {
2358 const size_t global_work_size[3] = { num_elements, 32, 1 };
2359 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2360
2361 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2362 }
2363 else
2364 {
2365 const size_t global_work_size[3] = { num_elements, 1, 1 };
2366 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2367
2368 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2369 }
2370
2371 hc_clFlush (device_param->command_queue);
2372
2373 hc_clFinish (device_param->command_queue);
2374 }
2375
2376 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2377 {
2378 uint num_elements = num;
2379
2380 switch (kern_run)
2381 {
2382 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2383 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2384 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2385 }
2386
2387 // causes problems with special threads like in bcrypt
2388 // const uint kernel_threads = device_param->kernel_threads;
2389
2390 const uint kernel_threads = KERNEL_THREADS;
2391
2392 while (num_elements % kernel_threads) num_elements++;
2393
2394 cl_kernel kernel = NULL;
2395
2396 switch (kern_run)
2397 {
2398 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2399 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2400 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2401 }
2402
2403 switch (kern_run)
2404 {
2405 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2406 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2407 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2408 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2409 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2410 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2411 break;
2412 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2413 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2414 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2415 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2416 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2417 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2418 break;
2419 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2420 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2421 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2422 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2423 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2424 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2425 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2426 break;
2427 }
2428
2429 const size_t global_work_size[3] = { num_elements, 1, 1 };
2430 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2431
2432 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2433
2434 hc_clFlush (device_param->command_queue);
2435
2436 hc_clFinish (device_param->command_queue);
2437 }
2438
2439 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2440 {
2441 uint num_elements = num;
2442
2443 uint kernel_threads = device_param->kernel_threads;
2444
2445 while (num_elements % kernel_threads) num_elements++;
2446
2447 cl_kernel kernel = device_param->kernel_tb;
2448
2449 const size_t global_work_size[3] = { num_elements, 1, 1 };
2450 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2451
2452 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2453
2454 hc_clFlush (device_param->command_queue);
2455
2456 hc_clFinish (device_param->command_queue);
2457 }
2458
2459 static void run_kernel_tm (hc_device_param_t *device_param)
2460 {
2461 const uint num_elements = 1024; // fixed
2462
2463 const uint kernel_threads = 32;
2464
2465 cl_kernel kernel = device_param->kernel_tm;
2466
2467 const size_t global_work_size[3] = { num_elements, 1, 1 };
2468 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2469
2470 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2471
2472 hc_clFlush (device_param->command_queue);
2473
2474 hc_clFinish (device_param->command_queue);
2475 }
2476
2477 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2478 {
2479 uint num_elements = num;
2480
2481 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2482 device_param->kernel_params_amp_buf32[6] = num_elements;
2483
2484 // causes problems with special threads like in bcrypt
2485 // const uint kernel_threads = device_param->kernel_threads;
2486
2487 const uint kernel_threads = KERNEL_THREADS;
2488
2489 while (num_elements % kernel_threads) num_elements++;
2490
2491 cl_kernel kernel = device_param->kernel_amp;
2492
2493 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2494 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2495
2496 const size_t global_work_size[3] = { num_elements, 1, 1 };
2497 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2498
2499 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2500
2501 hc_clFlush (device_param->command_queue);
2502
2503 hc_clFinish (device_param->command_queue);
2504 }
2505
2506 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2507 {
2508 if (data.vendor_id == VENDOR_ID_AMD)
2509 {
2510 const cl_uchar zero = 0;
2511
2512 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2513 }
2514
2515 if (data.vendor_id == VENDOR_ID_NV)
2516 {
2517 // NOTE: clEnqueueFillBuffer () always fails with -59
2518 // IOW, it's not supported by Nvidia ForceWare <= 352.21,
2519 // How's that possible, OpenCL 1.2 support is advertised??
2520 // We need to workaround...
2521
2522 #define FILLSZ 0x100000
2523
2524 char *tmp = (char *) mymalloc (FILLSZ);
2525
2526 memset (tmp, 0, FILLSZ);
2527
2528 for (uint i = 0; i < size; i += FILLSZ)
2529 {
2530 const int left = size - i;
2531
2532 const int fillsz = MIN (FILLSZ, left);
2533
2534 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2535 }
2536
2537 myfree (tmp);
2538 }
2539
2540 if (data.vendor_id == VENDOR_ID_POCL)
2541 {
2542 // NOTE: clEnqueueFillBuffer () segfaults with Ubuntu 15.04 pocl
2543 // We need to workaround...
2544
2545 #define FILLSZ 0x100000
2546
2547 char *tmp = (char *) mymalloc (FILLSZ);
2548
2549 memset (tmp, 0, FILLSZ);
2550
2551 for (uint i = 0; i < size; i += FILLSZ)
2552 {
2553 const int left = size - i;
2554
2555 const int fillsz = MIN (FILLSZ, left);
2556
2557 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2558 }
2559
2560 myfree (tmp);
2561 }
2562
2563 if (data.vendor_id == VENDOR_ID_UNKNOWN)
2564 {
2565 const cl_uchar zero = 0;
2566
2567 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2568 }
2569 }
2570
2571 static int run_rule_engine (const int rule_len, const char *rule_buf)
2572 {
2573 if (rule_len == 0)
2574 {
2575 return 0;
2576 }
2577 else if (rule_len == 1)
2578 {
2579 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2580 }
2581
2582 return 1;
2583 }
2584
2585 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2586 {
2587 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2588 {
2589 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2590 }
2591 else if (data.attack_kern == ATTACK_KERN_COMBI)
2592 {
2593 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2594 }
2595 else if (data.attack_kern == ATTACK_KERN_BF)
2596 {
2597 const uint64_t off = device_param->words_off;
2598
2599 device_param->kernel_params_mp_l_buf64[3] = off;
2600
2601 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2602 }
2603 }
2604
2605 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2606 {
2607 const uint kernel_loops = data.kernel_loops;
2608
2609 // init speed timer
2610
2611 uint speed_pos = device_param->speed_pos;
2612
2613 #ifdef _POSIX
2614 if (device_param->timer_speed.tv_sec == 0)
2615 {
2616 hc_timer_set (&device_param->timer_speed);
2617 }
2618 #endif
2619
2620 #ifdef _WIN
2621 if (device_param->timer_speed.QuadPart == 0)
2622 {
2623 hc_timer_set (&device_param->timer_speed);
2624 }
2625 #endif
2626
2627 // find higest password length, this is for optimization stuff
2628
2629 uint highest_pw_len = 0;
2630
2631 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2632 {
2633 }
2634 else if (data.attack_kern == ATTACK_KERN_COMBI)
2635 {
2636 }
2637 else if (data.attack_kern == ATTACK_KERN_BF)
2638 {
2639 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2640 + device_param->kernel_params_mp_l_buf32[5];
2641 }
2642
2643 // bitslice optimization stuff
2644
2645 if (data.attack_mode == ATTACK_MODE_BF)
2646 {
2647 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2648 {
2649 run_kernel_tb (device_param, pws_cnt);
2650 }
2651 }
2652
2653 // iteration type
2654
2655 uint innerloop_step = 0;
2656 uint innerloop_cnt = 0;
2657
2658 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2659 else innerloop_step = 1;
2660
2661 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2662 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2663 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2664
2665 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2666
2667 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2668 {
2669 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2670
2671 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2672
2673 if (data.devices_status == STATUS_CRACKED) break;
2674 if (data.devices_status == STATUS_ABORTED) break;
2675 if (data.devices_status == STATUS_QUIT) break;
2676 if (data.devices_status == STATUS_BYPASS) break;
2677
2678 if (data.salts_shown[salt_pos] == 1) continue;
2679
2680 salt_t *salt_buf = &data.salts_buf[salt_pos];
2681
2682 device_param->kernel_params_buf32[24] = salt_pos;
2683 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2684 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2685
2686 FILE *combs_fp = device_param->combs_fp;
2687
2688 if (data.attack_mode == ATTACK_MODE_COMBI)
2689 {
2690 rewind (combs_fp);
2691 }
2692
2693 // innerloops
2694
2695 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2696 {
2697 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2698
2699 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2700
2701 if (data.devices_status == STATUS_CRACKED) break;
2702 if (data.devices_status == STATUS_ABORTED) break;
2703 if (data.devices_status == STATUS_QUIT) break;
2704 if (data.devices_status == STATUS_BYPASS) break;
2705
2706 uint innerloop_left = innerloop_cnt - innerloop_pos;
2707
2708 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2709
2710 device_param->innerloop_pos = innerloop_pos;
2711 device_param->innerloop_left = innerloop_left;
2712
2713 device_param->kernel_params_buf32[27] = innerloop_left;
2714
2715 if (innerloop_left == 0) continue;
2716
2717 // initialize amplifiers
2718
2719 if (data.attack_mode == ATTACK_MODE_COMBI)
2720 {
2721 char line_buf[BUFSIZ];
2722
2723 uint i = 0;
2724
2725 while (i < innerloop_left)
2726 {
2727 if (feof (combs_fp)) break;
2728
2729 int line_len = fgetl (combs_fp, line_buf);
2730
2731 if (line_len >= PW_MAX1) continue;
2732
2733 line_len = convert_from_hex (line_buf, line_len);
2734
2735 char *line_buf_new = line_buf;
2736
2737 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2738 {
2739 char rule_buf_out[BLOCK_SIZE];
2740
2741 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2742
2743 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2744
2745 if (rule_len_out < 0)
2746 {
2747 data.words_progress_rejected[salt_pos] += pw_cnt;
2748
2749 continue;
2750 }
2751
2752 line_len = rule_len_out;
2753
2754 line_buf_new = rule_buf_out;
2755 }
2756
2757 line_len = MIN (line_len, PW_DICTMAX);
2758
2759 char *ptr = (char *) device_param->combs_buf[i].i;
2760
2761 memcpy (ptr, line_buf_new, line_len);
2762
2763 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2764
2765 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2766 {
2767 uppercase (ptr, line_len);
2768 }
2769
2770 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2771 {
2772 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2773 {
2774 ptr[line_len] = 0x80;
2775 }
2776
2777 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2778 {
2779 ptr[line_len] = 0x01;
2780 }
2781 }
2782
2783 device_param->combs_buf[i].pw_len = line_len;
2784
2785 i++;
2786 }
2787
2788 for (uint j = i; j < innerloop_left; j++)
2789 {
2790 device_param->combs_buf[j].i[0] = 0;
2791 device_param->combs_buf[j].i[1] = 0;
2792 device_param->combs_buf[j].i[2] = 0;
2793 device_param->combs_buf[j].i[3] = 0;
2794 device_param->combs_buf[j].i[4] = 0;
2795 device_param->combs_buf[j].i[5] = 0;
2796 device_param->combs_buf[j].i[6] = 0;
2797 device_param->combs_buf[j].i[7] = 0;
2798
2799 device_param->combs_buf[j].pw_len = 0;
2800 }
2801
2802 innerloop_left = i;
2803 }
2804 else if (data.attack_mode == ATTACK_MODE_BF)
2805 {
2806 uint64_t off = innerloop_pos;
2807
2808 device_param->kernel_params_mp_r_buf64[3] = off;
2809
2810 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2811 }
2812 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2813 {
2814 uint64_t off = innerloop_pos;
2815
2816 device_param->kernel_params_mp_buf64[3] = off;
2817
2818 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2819 }
2820 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2821 {
2822 uint64_t off = innerloop_pos;
2823
2824 device_param->kernel_params_mp_buf64[3] = off;
2825
2826 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2827 }
2828
2829 // copy amplifiers
2830
2831 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2832 {
2833 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
2834 }
2835 else if (data.attack_mode == ATTACK_MODE_COMBI)
2836 {
2837 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
2838 }
2839 else if (data.attack_mode == ATTACK_MODE_BF)
2840 {
2841 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
2842 }
2843 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2844 {
2845 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2846 }
2847 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2848 {
2849 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2850 }
2851
2852 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2853 {
2854 if (data.attack_mode == ATTACK_MODE_BF)
2855 {
2856 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2857 {
2858 const uint size_tm = 32 * sizeof (bs_word_t);
2859
2860 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2861
2862 run_kernel_tm (device_param);
2863
2864 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2865 }
2866 }
2867
2868 if (highest_pw_len < 16)
2869 {
2870 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2871 }
2872 else if (highest_pw_len < 32)
2873 {
2874 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2875 }
2876 else
2877 {
2878 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2879 }
2880 }
2881 else
2882 {
2883 run_kernel_amp (device_param, pws_cnt);
2884
2885 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2886
2887 if (data.opts_type & OPTS_TYPE_HOOK12)
2888 {
2889 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2890 }
2891
2892 uint iter = salt_buf->salt_iter;
2893
2894 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2895 {
2896 uint loop_left = iter - loop_pos;
2897
2898 loop_left = MIN (loop_left, kernel_loops);
2899
2900 device_param->kernel_params_buf32[25] = loop_pos;
2901 device_param->kernel_params_buf32[26] = loop_left;
2902
2903 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2904
2905 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2906
2907 if (data.devices_status == STATUS_CRACKED) break;
2908 if (data.devices_status == STATUS_ABORTED) break;
2909 if (data.devices_status == STATUS_QUIT) break;
2910 }
2911
2912 if (data.opts_type & OPTS_TYPE_HOOK23)
2913 {
2914 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2915
2916 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2917
2918 // do something with data
2919
2920 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2921 }
2922
2923 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2924 }
2925
2926 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2927
2928 if (data.devices_status == STATUS_CRACKED) break;
2929 if (data.devices_status == STATUS_ABORTED) break;
2930 if (data.devices_status == STATUS_QUIT) break;
2931
2932 /**
2933 * result
2934 */
2935
2936 hc_thread_mutex_lock (mux_display);
2937
2938 check_cracked (device_param, salt_pos);
2939
2940 hc_thread_mutex_unlock (mux_display);
2941
2942 /**
2943 * progress
2944 */
2945
2946 uint64_t perf_sum_all = (uint64_t) pw_cnt * (uint64_t) innerloop_left;
2947
2948 hc_thread_mutex_lock (mux_counter);
2949
2950 data.words_progress_done[salt_pos] += perf_sum_all;
2951
2952 hc_thread_mutex_unlock (mux_counter);
2953
2954 /**
2955 * speed
2956 */
2957
2958 float speed_ms;
2959
2960 hc_timer_get (device_param->timer_speed, speed_ms);
2961
2962 hc_timer_set (&device_param->timer_speed);
2963
2964 hc_thread_mutex_lock (mux_display);
2965
2966 device_param->speed_cnt[speed_pos] = perf_sum_all;
2967
2968 device_param->speed_ms[speed_pos] = speed_ms;
2969
2970 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2971
2972 hc_thread_mutex_unlock (mux_display);
2973
2974 speed_pos++;
2975
2976 if (speed_pos == SPEED_CACHE)
2977 {
2978 speed_pos = 0;
2979 }
2980 }
2981 }
2982
2983 device_param->speed_pos = speed_pos;
2984 }
2985
2986 static void load_segment (wl_data_t *wl_data, FILE *fd)
2987 {
2988 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2989
2990 wl_data->pos = 0;
2991
2992 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
2993
2994 wl_data->buf[wl_data->cnt] = 0;
2995
2996 if (wl_data->cnt == 0) return;
2997
2998 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
2999
3000 while (!feof (fd))
3001 {
3002 if (wl_data->cnt == wl_data->avail)
3003 {
3004 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3005
3006 wl_data->avail += wl_data->incr;
3007 }
3008
3009 const int c = fgetc (fd);
3010
3011 if (c == EOF) break;
3012
3013 wl_data->buf[wl_data->cnt] = (char) c;
3014
3015 wl_data->cnt++;
3016
3017 if (c == '\n') break;
3018 }
3019
3020 // ensure stream ends with a newline
3021
3022 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3023 {
3024 wl_data->cnt++;
3025
3026 wl_data->buf[wl_data->cnt - 1] = '\n';
3027 }
3028
3029 return;
3030 }
3031
3032 static void get_next_word_lm (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3033 {
3034 char *ptr = buf;
3035
3036 for (uint32_t i = 0; i < sz; i++, ptr++)
3037 {
3038 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3039
3040 if (i == 7)
3041 {
3042 *off = i;
3043 *len = i;
3044
3045 return;
3046 }
3047
3048 if (*ptr != '\n') continue;
3049
3050 *off = i + 1;
3051
3052 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3053
3054 *len = i;
3055
3056 return;
3057 }
3058
3059 *off = sz;
3060 *len = sz;
3061 }
3062
3063 static void get_next_word_uc (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3064 {
3065 char *ptr = buf;
3066
3067 for (uint32_t i = 0; i < sz; i++, ptr++)
3068 {
3069 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3070
3071 if (*ptr != '\n') continue;
3072
3073 *off = i + 1;
3074
3075 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3076
3077 *len = i;
3078
3079 return;
3080 }
3081
3082 *off = sz;
3083 *len = sz;
3084 }
3085
3086 static void get_next_word_std (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3087 {
3088 char *ptr = buf;
3089
3090 for (uint32_t i = 0; i < sz; i++, ptr++)
3091 {
3092 if (*ptr != '\n') continue;
3093
3094 *off = i + 1;
3095
3096 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3097
3098 *len = i;
3099
3100 return;
3101 }
3102
3103 *off = sz;
3104 *len = sz;
3105 }
3106
3107 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3108 {
3109 while (wl_data->pos < wl_data->cnt)
3110 {
3111 uint off;
3112 uint len;
3113
3114 char *ptr = wl_data->buf + wl_data->pos;
3115
3116 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3117
3118 wl_data->pos += off;
3119
3120 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3121 {
3122 char rule_buf_out[BLOCK_SIZE];
3123
3124 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3125
3126 int rule_len_out = -1;
3127
3128 if (len < BLOCK_SIZE)
3129 {
3130 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3131 }
3132
3133 if (rule_len_out < 0)
3134 {
3135 continue;
3136 }
3137
3138 if (rule_len_out > PW_MAX)
3139 {
3140 continue;
3141 }
3142 }
3143 else
3144 {
3145 if (len > PW_MAX)
3146 {
3147 continue;
3148 }
3149 }
3150
3151 *out_buf = ptr;
3152 *out_len = len;
3153
3154 return;
3155 }
3156
3157 if (feof (fd))
3158 {
3159 fprintf (stderr, "bug!!\n");
3160
3161 return;
3162 }
3163
3164 load_segment (wl_data, fd);
3165
3166 get_next_word (wl_data, fd, out_buf, out_len);
3167 }
3168
3169 #ifdef _POSIX
3170 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3171 #endif
3172
3173 #ifdef _WIN
3174 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3175 #endif
3176 {
3177 hc_signal (NULL);
3178
3179 dictstat_t d;
3180
3181 d.cnt = 0;
3182
3183 #ifdef _POSIX
3184 fstat (fileno (fd), &d.stat);
3185 #endif
3186
3187 #ifdef _WIN
3188 _fstat64 (fileno (fd), &d.stat);
3189 #endif
3190
3191 d.stat.st_mode = 0;
3192 d.stat.st_nlink = 0;
3193 d.stat.st_uid = 0;
3194 d.stat.st_gid = 0;
3195 d.stat.st_rdev = 0;
3196 d.stat.st_atime = 0;
3197
3198 #ifdef _POSIX
3199 d.stat.st_blksize = 0;
3200 d.stat.st_blocks = 0;
3201 #endif
3202
3203 if (d.stat.st_size == 0) return 0;
3204
3205 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3206
3207 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3208 {
3209 if (d_cache)
3210 {
3211 uint64_t cnt = d_cache->cnt;
3212
3213 uint64_t keyspace = cnt;
3214
3215 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3216 {
3217 keyspace *= data.kernel_rules_cnt;
3218 }
3219 else if (data.attack_kern == ATTACK_KERN_COMBI)
3220 {
3221 keyspace *= data.combs_cnt;
3222 }
3223
3224 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3225 if (data.quiet == 0) log_info ("");
3226
3227 hc_signal (sigHandler_default);
3228
3229 return (keyspace);
3230 }
3231 }
3232
3233 time_t now = 0;
3234 time_t prev = 0;
3235
3236 uint64_t comp = 0;
3237 uint64_t cnt = 0;
3238 uint64_t cnt2 = 0;
3239
3240 while (!feof (fd))
3241 {
3242 load_segment (wl_data, fd);
3243
3244 comp += wl_data->cnt;
3245
3246 uint32_t i = 0;
3247
3248 while (i < wl_data->cnt)
3249 {
3250 uint32_t len;
3251 uint32_t off;
3252
3253 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3254
3255 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3256 {
3257 char rule_buf_out[BLOCK_SIZE];
3258
3259 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3260
3261 int rule_len_out = -1;
3262
3263 if (len < BLOCK_SIZE)
3264 {
3265 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3266 }
3267
3268 if (rule_len_out < 0)
3269 {
3270 len = PW_MAX1;
3271 }
3272 else
3273 {
3274 len = rule_len_out;
3275 }
3276 }
3277
3278 if (len < PW_MAX1)
3279 {
3280 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3281 {
3282 cnt += data.kernel_rules_cnt;
3283 }
3284 else if (data.attack_kern == ATTACK_KERN_COMBI)
3285 {
3286 cnt += data.combs_cnt;
3287 }
3288
3289 d.cnt++;
3290 }
3291
3292 i += off;
3293
3294 cnt2++;
3295 }
3296
3297 time (&now);
3298
3299 if ((now - prev) == 0) continue;
3300
3301 float percent = (float) comp / (float) d.stat.st_size;
3302
3303 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3304
3305 time (&prev);
3306 }
3307
3308 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3309 if (data.quiet == 0) log_info ("");
3310
3311 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3312
3313 hc_signal (sigHandler_default);
3314
3315 return (cnt);
3316 }
3317
3318 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3319 {
3320 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3321 }
3322
3323 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
3324 {
3325 if (data.devices_status == STATUS_BYPASS) return 0;
3326
3327 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3328
3329 uint cache_cnt = pw_cache->cnt;
3330
3331 uint8_t *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3332
3333 memcpy (pw_hc1, pw_buf, pw_len);
3334
3335 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3336
3337 uint pws_cnt = device_param->pws_cnt;
3338
3339 cache_cnt++;
3340
3341 pw_t *pw = device_param->pws_buf + pws_cnt;
3342
3343 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3344
3345 pw->pw_len = pw_len;
3346
3347 pws_cnt++;
3348
3349 device_param->pws_cnt = pws_cnt;
3350 device_param->pw_cnt = pws_cnt * 1;
3351
3352 cache_cnt = 0;
3353
3354 pw_cache->cnt = cache_cnt;
3355
3356 return pws_cnt;
3357 }
3358
3359 static void *thread_monitor (void *p)
3360 {
3361 uint runtime_check = 0;
3362 uint remove_check = 0;
3363 uint status_check = 0;
3364 uint hwmon_check = 0;
3365 uint restore_check = 0;
3366
3367 uint restore_left = data.restore_timer;
3368 uint remove_left = data.remove_timer;
3369 uint status_left = data.status_timer;
3370
3371 // these variables are mainly used for fan control (AMD only)
3372
3373 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3374
3375 // temperature controller "loopback" values
3376
3377 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3378 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3379
3380 int temp_threshold = 1; // degrees celcius
3381
3382 int fan_speed_min = 15; // in percentage
3383 int fan_speed_max = 100;
3384
3385 time_t last_temp_check_time;
3386
3387 uint sleep_time = 1;
3388
3389 if (data.runtime)
3390 {
3391 runtime_check = 1;
3392 }
3393
3394 if (data.restore_timer)
3395 {
3396 restore_check = 1;
3397 }
3398
3399 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3400 {
3401 remove_check = 1;
3402 }
3403
3404 if (data.status == 1)
3405 {
3406 status_check = 1;
3407 }
3408
3409 if (data.gpu_temp_disable == 0)
3410 {
3411 time (&last_temp_check_time);
3412
3413 hwmon_check = 1;
3414 }
3415
3416 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3417 {
3418 return (p);
3419 }
3420
3421 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3422 {
3423 hc_sleep (sleep_time);
3424
3425 if (data.devices_status != STATUS_RUNNING) continue;
3426
3427 if (hwmon_check == 1)
3428 {
3429 hc_thread_mutex_lock (mux_adl);
3430
3431 time_t temp_check_time;
3432
3433 time (&temp_check_time);
3434
3435 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3436
3437 if (Ta == 0) Ta = 1;
3438
3439 for (uint i = 0; i < data.devices_cnt; i++)
3440 {
3441 const int temperature = hm_get_temperature_with_device_id (i);
3442
3443 if (temperature > (int) data.gpu_temp_abort)
3444 {
3445 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", i + 1);
3446
3447 if (data.devices_status != STATUS_QUIT) myabort ();
3448
3449 break;
3450 }
3451
3452 const int gpu_temp_retain = data.gpu_temp_retain;
3453
3454 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3455 {
3456 if (data.hm_device[i].fan_supported == 1)
3457 {
3458 int temp_cur = temperature;
3459
3460 int temp_diff_new = gpu_temp_retain - temp_cur;
3461
3462 temp_diff_sum[i] = temp_diff_sum[i] + temp_diff_new;
3463
3464 // calculate Ta value (time difference in seconds between the last check and this check)
3465
3466 last_temp_check_time = temp_check_time;
3467
3468 float Kp = 1.8;
3469 float Ki = 0.005;
3470 float Kd = 6;
3471
3472 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3473
3474 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[i] + Kd * ((float)(temp_diff_new - temp_diff_old[i])) / Ta);
3475
3476 if (abs (fan_diff_required) >= temp_threshold)
3477 {
3478 const int fan_speed_cur = hm_get_fanspeed_with_device_id (i);
3479
3480 int fan_speed_level = fan_speed_cur;
3481
3482 if (fan_speed_chgd[i] == 0) fan_speed_level = temp_cur;
3483
3484 int fan_speed_new = fan_speed_level - fan_diff_required;
3485
3486 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3487 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3488
3489 if (fan_speed_new != fan_speed_cur)
3490 {
3491 int freely_change_fan_speed = (fan_speed_chgd[i] == 1);
3492 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3493
3494 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3495 {
3496 hm_set_fanspeed_with_device_id_amd (i, fan_speed_new);
3497
3498 fan_speed_chgd[i] = 1;
3499 }
3500
3501 temp_diff_old[i] = temp_diff_new;
3502 }
3503 }
3504 }
3505 }
3506 }
3507
3508 hc_thread_mutex_unlock (mux_adl);
3509 }
3510
3511 if (restore_check == 1)
3512 {
3513 restore_left--;
3514
3515 if (restore_left == 0)
3516 {
3517 if (data.restore_disable == 0) cycle_restore ();
3518
3519 restore_left = data.restore_timer;
3520 }
3521 }
3522
3523 if ((runtime_check == 1) && (data.runtime_start > 0))
3524 {
3525 time_t runtime_cur;
3526
3527 time (&runtime_cur);
3528
3529 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3530
3531 if (runtime_left <= 0)
3532 {
3533 if (data.benchmark == 0)
3534 {
3535 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3536 }
3537
3538 if (data.devices_status != STATUS_QUIT) myabort ();
3539 }
3540 }
3541
3542 if (remove_check == 1)
3543 {
3544 remove_left--;
3545
3546 if (remove_left == 0)
3547 {
3548 if (data.digests_saved != data.digests_done)
3549 {
3550 data.digests_saved = data.digests_done;
3551
3552 save_hash ();
3553 }
3554
3555 remove_left = data.remove_timer;
3556 }
3557 }
3558
3559 if (status_check == 1)
3560 {
3561 status_left--;
3562
3563 if (status_left == 0)
3564 {
3565 hc_thread_mutex_lock (mux_display);
3566
3567 if (data.quiet == 0) clear_prompt ();
3568
3569 if (data.quiet == 0) log_info ("");
3570
3571 status_display ();
3572
3573 if (data.quiet == 0) log_info ("");
3574
3575 hc_thread_mutex_unlock (mux_display);
3576
3577 status_left = data.status_timer;
3578 }
3579 }
3580 }
3581
3582 myfree (fan_speed_chgd);
3583
3584 myfree (temp_diff_old);
3585 myfree (temp_diff_sum);
3586
3587 p = NULL;
3588
3589 return (p);
3590 }
3591
3592 static void *thread_outfile_remove (void *p)
3593 {
3594 // some hash-dependent constants
3595 char *outfile_dir = data.outfile_check_directory;
3596 uint dgst_size = data.dgst_size;
3597 uint isSalted = data.isSalted;
3598 uint esalt_size = data.esalt_size;
3599 uint hash_mode = data.hash_mode;
3600
3601 uint outfile_check_timer = data.outfile_check_timer;
3602
3603 char separator = data.separator;
3604
3605 // some hash-dependent functions
3606 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3607 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3608
3609 // buffers
3610 hash_t hash_buf;
3611
3612 memset (&hash_buf, 0, sizeof (hash_buf));
3613
3614 hash_buf.digest = mymalloc (dgst_size);
3615
3616 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3617
3618 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3619
3620 uint digest_buf[64];
3621
3622 outfile_data_t *out_info = NULL;
3623
3624 char **out_files = NULL;
3625
3626 time_t folder_mtime = 0;
3627
3628 int out_cnt = 0;
3629
3630 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3631
3632 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3633 {
3634 hc_sleep (1);
3635
3636 if (data.devices_status != STATUS_RUNNING) continue;
3637
3638 check_left--;
3639
3640 if (check_left == 0)
3641 {
3642 struct stat outfile_check_stat;
3643
3644 if (stat (outfile_dir, &outfile_check_stat) == 0)
3645 {
3646 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3647
3648 if (is_dir == 1)
3649 {
3650 if (outfile_check_stat.st_mtime > folder_mtime)
3651 {
3652 char **out_files_new = scan_directory (outfile_dir);
3653
3654 int out_cnt_new = count_dictionaries (out_files_new);
3655
3656 outfile_data_t *out_info_new = NULL;
3657
3658 if (out_cnt_new > 0)
3659 {
3660 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3661
3662 for (int i = 0; i < out_cnt_new; i++)
3663 {
3664 out_info_new[i].file_name = out_files_new[i];
3665
3666 // check if there are files that we have seen/checked before (and not changed)
3667
3668 for (int j = 0; j < out_cnt; j++)
3669 {
3670 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3671 {
3672 struct stat outfile_stat;
3673
3674 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3675 {
3676 if (outfile_stat.st_ctime == out_info[j].ctime)
3677 {
3678 out_info_new[i].ctime = out_info[j].ctime;
3679 out_info_new[i].seek = out_info[j].seek;
3680 }
3681 }
3682 }
3683 }
3684 }
3685 }
3686
3687 local_free (out_info);
3688 local_free (out_files);
3689
3690 out_files = out_files_new;
3691 out_cnt = out_cnt_new;
3692 out_info = out_info_new;
3693
3694 folder_mtime = outfile_check_stat.st_mtime;
3695 }
3696
3697 for (int j = 0; j < out_cnt; j++)
3698 {
3699 FILE *fp = fopen (out_info[j].file_name, "rb");
3700
3701 if (fp != NULL)
3702 {
3703 //hc_thread_mutex_lock (mux_display);
3704
3705 #ifdef _POSIX
3706 struct stat outfile_stat;
3707
3708 fstat (fileno (fp), &outfile_stat);
3709 #endif
3710
3711 #ifdef _WIN
3712 struct stat64 outfile_stat;
3713
3714 _fstat64 (fileno (fp), &outfile_stat);
3715 #endif
3716
3717 if (outfile_stat.st_ctime > out_info[j].ctime)
3718 {
3719 out_info[j].ctime = outfile_stat.st_ctime;
3720 out_info[j].seek = 0;
3721 }
3722
3723 fseek (fp, out_info[j].seek, SEEK_SET);
3724
3725 while (!feof (fp))
3726 {
3727 char line_buf[BUFSIZ];
3728
3729 memset (line_buf, 0, BUFSIZ);
3730
3731 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3732
3733 if (ptr == NULL) break;
3734
3735 int line_len = strlen (line_buf);
3736
3737 if (line_len <= 0) continue;
3738
3739 int iter = MAX_CUT_TRIES;
3740
3741 for (uint i = line_len - 1; i && iter; i--, line_len--)
3742 {
3743 if (line_buf[i] != separator) continue;
3744
3745 int parser_status = PARSER_OK;
3746
3747 if ((hash_mode != 2500) && (hash_mode != 6800))
3748 {
3749 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3750 }
3751
3752 uint found = 0;
3753
3754 if (parser_status == PARSER_OK)
3755 {
3756 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3757 {
3758 if (data.salts_shown[salt_pos] == 1) continue;
3759
3760 salt_t *salt_buf = &data.salts_buf[salt_pos];
3761
3762 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3763 {
3764 uint idx = salt_buf->digests_offset + digest_pos;
3765
3766 if (data.digests_shown[idx] == 1) continue;
3767
3768 uint cracked = 0;
3769
3770 if (hash_mode == 6800)
3771 {
3772 if (i == salt_buf->salt_len)
3773 {
3774 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3775 }
3776 }
3777 else if (hash_mode == 2500)
3778 {
3779 // BSSID : MAC1 : MAC2 (:plain)
3780 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3781 {
3782 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3783
3784 if (!cracked) continue;
3785
3786 // now compare MAC1 and MAC2 too, since we have this additional info
3787 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3788 char *mac2_pos = mac1_pos + 12 + 1;
3789
3790 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3791 wpa_t *wpa = &wpas[salt_pos];
3792
3793 uint pke[25];
3794
3795 char *pke_ptr = (char *) pke;
3796
3797 for (uint i = 0; i < 25; i++)
3798 {
3799 pke[i] = byte_swap_32 (wpa->pke[i]);
3800 }
3801
3802 unsigned char mac1[6];
3803 unsigned char mac2[6];
3804
3805 memcpy (mac1, pke_ptr + 23, 6);
3806 memcpy (mac2, pke_ptr + 29, 6);
3807
3808 // compare hex string(s) vs binary MAC address(es)
3809
3810 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3811 {
3812 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
3813 {
3814 cracked = 0;
3815 break;
3816 }
3817 }
3818
3819 // early skip ;)
3820 if (!cracked) continue;
3821
3822 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3823 {
3824 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
3825 {
3826 cracked = 0;
3827 break;
3828 }
3829 }
3830 }
3831 }
3832 else
3833 {
3834 char *digests_buf_ptr = (char *) data.digests_buf;
3835
3836 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3837
3838 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3839 }
3840
3841 if (cracked == 1)
3842 {
3843 found = 1;
3844
3845 data.digests_shown[idx] = 1;
3846
3847 data.digests_done++;
3848
3849 salt_buf->digests_done++;
3850
3851 if (salt_buf->digests_done == salt_buf->digests_cnt)
3852 {
3853 data.salts_shown[salt_pos] = 1;
3854
3855 data.salts_done++;
3856
3857 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3858 }
3859 }
3860 }
3861
3862 if (data.devices_status == STATUS_CRACKED) break;
3863 }
3864 }
3865
3866 if (found) break;
3867
3868 if (data.devices_status == STATUS_CRACKED) break;
3869
3870 iter--;
3871 }
3872
3873 if (data.devices_status == STATUS_CRACKED) break;
3874 }
3875
3876 out_info[j].seek = ftell (fp);
3877
3878 //hc_thread_mutex_unlock (mux_display);
3879
3880 fclose (fp);
3881 }
3882 }
3883 }
3884 }
3885
3886 check_left = outfile_check_timer;
3887 }
3888 }
3889
3890 if (esalt_size) local_free (hash_buf.esalt);
3891
3892 if (isSalted) local_free (hash_buf.salt);
3893
3894 local_free (hash_buf.digest);
3895
3896 local_free (out_info);
3897
3898 local_free (out_files);
3899
3900 p = NULL;
3901
3902 return (p);
3903 }
3904
3905 static uint get_work (hc_device_param_t *device_param, const uint64_t max)
3906 {
3907 hc_thread_mutex_lock (mux_dispatcher);
3908
3909 const uint64_t words_cur = data.words_cur;
3910 const uint64_t words_base = (data.limit == 0) ? data.words_base : data.limit;
3911
3912 device_param->words_off = words_cur;
3913
3914 const uint64_t words_left = words_base - words_cur;
3915
3916 if (data.kernel_blocks_all > words_left)
3917 {
3918 if (data.kernel_blocks_div == 0)
3919 {
3920 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3921 }
3922 }
3923
3924 if (data.kernel_blocks_div)
3925 {
3926 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3927 {
3928 const uint32_t kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3929 const uint32_t kernel_power_new = kernel_blocks_new;
3930
3931 if (kernel_blocks_new < device_param->kernel_blocks)
3932 {
3933 device_param->kernel_blocks = kernel_blocks_new;
3934 device_param->kernel_power = kernel_power_new;
3935 }
3936 }
3937 }
3938
3939 const uint kernel_blocks = device_param->kernel_blocks;
3940
3941 uint work = MIN (words_left, kernel_blocks);
3942
3943 work = MIN (work, max);
3944
3945 data.words_cur += work;
3946
3947 hc_thread_mutex_unlock (mux_dispatcher);
3948
3949 return work;
3950 }
3951
3952 static void *thread_calc_stdin (void *p)
3953 {
3954 hc_device_param_t *device_param = (hc_device_param_t *) p;
3955
3956 const uint attack_kern = data.attack_kern;
3957
3958 const uint kernel_blocks = device_param->kernel_blocks;
3959
3960 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3961 {
3962 hc_thread_mutex_lock (mux_dispatcher);
3963
3964 if (feof (stdin) != 0)
3965 {
3966 hc_thread_mutex_unlock (mux_dispatcher);
3967
3968 break;
3969 }
3970
3971 uint words_cur = 0;
3972
3973 while (words_cur < kernel_blocks)
3974 {
3975 char buf[BUFSIZ];
3976
3977 char *line_buf = fgets (buf, sizeof (buf), stdin);
3978
3979 if (line_buf == NULL) break;
3980
3981 uint line_len = in_superchop (line_buf);
3982
3983 line_len = convert_from_hex (line_buf, line_len);
3984
3985 // post-process rule engine
3986
3987 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3988 {
3989 char rule_buf_out[BLOCK_SIZE];
3990
3991 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3992
3993 int rule_len_out = -1;
3994
3995 if (line_len < BLOCK_SIZE)
3996 {
3997 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
3998 }
3999
4000 if (rule_len_out < 0) continue;
4001
4002 line_buf = rule_buf_out;
4003 line_len = rule_len_out;
4004 }
4005
4006 if (line_len > PW_MAX)
4007 {
4008 continue;
4009 }
4010
4011 if (attack_kern == ATTACK_KERN_STRAIGHT)
4012 {
4013 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4014 {
4015 hc_thread_mutex_lock (mux_counter);
4016
4017 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4018 {
4019 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4020 }
4021
4022 hc_thread_mutex_unlock (mux_counter);
4023
4024 continue;
4025 }
4026 }
4027 else if (attack_kern == ATTACK_KERN_COMBI)
4028 {
4029 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4030 // since we still need to combine the plains
4031
4032 if (line_len > data.pw_max)
4033 {
4034 hc_thread_mutex_lock (mux_counter);
4035
4036 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4037 {
4038 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4039 }
4040
4041 hc_thread_mutex_unlock (mux_counter);
4042
4043 continue;
4044 }
4045 }
4046
4047 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4048
4049 words_cur++;
4050
4051 if (data.devices_status == STATUS_CRACKED) break;
4052 if (data.devices_status == STATUS_ABORTED) break;
4053 if (data.devices_status == STATUS_QUIT) break;
4054 if (data.devices_status == STATUS_BYPASS) break;
4055 }
4056
4057 hc_thread_mutex_unlock (mux_dispatcher);
4058
4059 if (data.devices_status == STATUS_CRACKED) break;
4060 if (data.devices_status == STATUS_ABORTED) break;
4061 if (data.devices_status == STATUS_QUIT) break;
4062 if (data.devices_status == STATUS_BYPASS) break;
4063
4064 // we need 2 flushing because we have two independant caches and it can occur
4065 // that one buffer is already at threshold plus for that length also exists
4066 // more data in the 2nd buffer so it would overflow
4067
4068 // flush session 1
4069
4070 {
4071 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4072 {
4073 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4074
4075 const uint pw_cache_cnt = pw_cache->cnt;
4076
4077 if (pw_cache_cnt == 0) continue;
4078
4079 pw_cache->cnt = 0;
4080
4081 uint pws_cnt = device_param->pws_cnt;
4082
4083 pw_t *pw = device_param->pws_buf + pws_cnt;
4084
4085 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4086
4087 pw->pw_len = pw_len;
4088
4089 uint pw_cnt = device_param->pw_cnt;
4090
4091 pw_cnt += pw_cache_cnt;
4092
4093 device_param->pw_cnt = pw_cnt;
4094
4095 pws_cnt++;
4096
4097 device_param->pws_cnt = pws_cnt;
4098
4099 if (pws_cnt == device_param->kernel_power_user) break;
4100 }
4101
4102 const uint pw_cnt = device_param->pw_cnt;
4103 const uint pws_cnt = device_param->pws_cnt;
4104
4105 if (pws_cnt)
4106 {
4107 run_copy (device_param, pws_cnt);
4108
4109 run_cracker (device_param, pw_cnt, pws_cnt);
4110
4111 device_param->pw_cnt = 0;
4112 device_param->pws_cnt = 0;
4113 }
4114 }
4115
4116 // flush session 2
4117
4118 {
4119 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4120 {
4121 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4122
4123 const uint pw_cache_cnt = pw_cache->cnt;
4124
4125 if (pw_cache_cnt == 0) continue;
4126
4127 pw_cache->cnt = 0;
4128
4129 uint pws_cnt = device_param->pws_cnt;
4130
4131 pw_t *pw = device_param->pws_buf + pws_cnt;
4132
4133 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4134
4135 pw->pw_len = pw_len;
4136
4137 uint pw_cnt = device_param->pw_cnt;
4138
4139 pw_cnt += pw_cache_cnt;
4140
4141 device_param->pw_cnt = pw_cnt;
4142
4143 pws_cnt++;
4144
4145 device_param->pws_cnt = pws_cnt;
4146 }
4147
4148 const uint pw_cnt = device_param->pw_cnt;
4149 const uint pws_cnt = device_param->pws_cnt;
4150
4151 if (pws_cnt)
4152 {
4153 run_copy (device_param, pws_cnt);
4154
4155 run_cracker (device_param, pw_cnt, pws_cnt);
4156
4157 device_param->pw_cnt = 0;
4158 device_param->pws_cnt = 0;
4159 }
4160 }
4161 }
4162
4163 return NULL;
4164 }
4165
4166 static void *thread_calc (void *p)
4167 {
4168 hc_device_param_t *device_param = (hc_device_param_t *) p;
4169
4170 const uint attack_mode = data.attack_mode;
4171 const uint attack_kern = data.attack_kern;
4172
4173 if (attack_mode == ATTACK_MODE_BF)
4174 {
4175 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4176 {
4177 const uint work = get_work (device_param, -1);
4178
4179 if (work == 0) break;
4180
4181 const uint64_t words_off = device_param->words_off;
4182 const uint64_t words_fin = words_off + work;
4183
4184 const uint pw_cnt = work;
4185 const uint pws_cnt = work;
4186
4187 device_param->pw_cnt = pw_cnt;
4188 device_param->pws_cnt = pws_cnt;
4189
4190 if (pws_cnt)
4191 {
4192 run_copy (device_param, pws_cnt);
4193
4194 run_cracker (device_param, pw_cnt, pws_cnt);
4195
4196 device_param->pw_cnt = 0;
4197 device_param->pws_cnt = 0;
4198 }
4199
4200 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4201
4202 if (data.devices_status == STATUS_CRACKED) break;
4203 if (data.devices_status == STATUS_ABORTED) break;
4204 if (data.devices_status == STATUS_QUIT) break;
4205 if (data.devices_status == STATUS_BYPASS) break;
4206
4207 device_param->words_done = words_fin;
4208 }
4209 }
4210 else
4211 {
4212 const uint segment_size = data.segment_size;
4213
4214 char *dictfile = data.dictfile;
4215
4216 if (attack_mode == ATTACK_MODE_COMBI)
4217 {
4218 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4219 {
4220 dictfile = data.dictfile2;
4221 }
4222 }
4223
4224 FILE *fd = fopen (dictfile, "rb");
4225
4226 if (fd == NULL)
4227 {
4228 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4229
4230 return NULL;
4231 }
4232
4233 if (attack_mode == ATTACK_MODE_COMBI)
4234 {
4235 const uint combs_mode = data.combs_mode;
4236
4237 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4238 {
4239 const char *dictfilec = data.dictfile2;
4240
4241 FILE *combs_fp = fopen (dictfilec, "rb");
4242
4243 if (combs_fp == NULL)
4244 {
4245 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4246
4247 fclose (fd);
4248
4249 return NULL;
4250 }
4251
4252 device_param->combs_fp = combs_fp;
4253 }
4254 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4255 {
4256 const char *dictfilec = data.dictfile;
4257
4258 FILE *combs_fp = fopen (dictfilec, "rb");
4259
4260 if (combs_fp == NULL)
4261 {
4262 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4263
4264 fclose (fd);
4265
4266 return NULL;
4267 }
4268
4269 device_param->combs_fp = combs_fp;
4270 }
4271 }
4272
4273 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4274
4275 wl_data->buf = (char *) mymalloc (segment_size);
4276 wl_data->avail = segment_size;
4277 wl_data->incr = segment_size;
4278 wl_data->cnt = 0;
4279 wl_data->pos = 0;
4280
4281 uint64_t words_cur = 0;
4282
4283 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4284 {
4285 uint64_t words_off = 0;
4286 uint64_t words_fin = 0;
4287
4288 uint64_t max = -1;
4289
4290 while (max)
4291 {
4292 const uint work = get_work (device_param, max);
4293
4294 if (work == 0) break;
4295
4296 words_off = device_param->words_off;
4297 words_fin = words_off + work;
4298
4299 char *line_buf;
4300 uint line_len;
4301
4302 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4303
4304 max = 0;
4305
4306 for ( ; words_cur < words_fin; words_cur++)
4307 {
4308 get_next_word (wl_data, fd, &line_buf, &line_len);
4309
4310 line_len = convert_from_hex (line_buf, line_len);
4311
4312 // post-process rule engine
4313
4314 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4315 {
4316 char rule_buf_out[BLOCK_SIZE];
4317
4318 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4319
4320 int rule_len_out = -1;
4321
4322 if (line_len < BLOCK_SIZE)
4323 {
4324 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4325 }
4326
4327 if (rule_len_out < 0) continue;
4328
4329 line_buf = rule_buf_out;
4330 line_len = rule_len_out;
4331 }
4332
4333 if (attack_kern == ATTACK_KERN_STRAIGHT)
4334 {
4335 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4336 {
4337 max++;
4338
4339 hc_thread_mutex_lock (mux_counter);
4340
4341 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4342 {
4343 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4344 }
4345
4346 hc_thread_mutex_unlock (mux_counter);
4347
4348 continue;
4349 }
4350 }
4351 else if (attack_kern == ATTACK_KERN_COMBI)
4352 {
4353 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4354 // since we still need to combine the plains
4355
4356 if (line_len > data.pw_max)
4357 {
4358 max++;
4359
4360 hc_thread_mutex_lock (mux_counter);
4361
4362 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4363 {
4364 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4365 }
4366
4367 hc_thread_mutex_unlock (mux_counter);
4368
4369 continue;
4370 }
4371 }
4372
4373 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4374
4375 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4376
4377 if (data.devices_status == STATUS_CRACKED) break;
4378 if (data.devices_status == STATUS_ABORTED) break;
4379 if (data.devices_status == STATUS_QUIT) break;
4380 if (data.devices_status == STATUS_BYPASS) break;
4381 }
4382
4383 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4384
4385 if (data.devices_status == STATUS_CRACKED) break;
4386 if (data.devices_status == STATUS_ABORTED) break;
4387 if (data.devices_status == STATUS_QUIT) break;
4388 if (data.devices_status == STATUS_BYPASS) break;
4389 }
4390
4391 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4392
4393 if (data.devices_status == STATUS_CRACKED) break;
4394 if (data.devices_status == STATUS_ABORTED) break;
4395 if (data.devices_status == STATUS_QUIT) break;
4396 if (data.devices_status == STATUS_BYPASS) break;
4397
4398 // we need 2 flushing because we have two independant caches and it can occur
4399 // that one buffer is already at threshold plus for that length also exists
4400 // more data in the 2nd buffer so it would overflow
4401
4402 //
4403 // flush session 1
4404 //
4405
4406 {
4407 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4408 {
4409 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4410
4411 const uint pw_cache_cnt = pw_cache->cnt;
4412
4413 if (pw_cache_cnt == 0) continue;
4414
4415 pw_cache->cnt = 0;
4416
4417 uint pws_cnt = device_param->pws_cnt;
4418
4419 pw_t *pw = device_param->pws_buf + pws_cnt;
4420
4421 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4422
4423 pw->pw_len = pw_len;
4424
4425 uint pw_cnt = device_param->pw_cnt;
4426
4427 pw_cnt += pw_cache_cnt;
4428
4429 device_param->pw_cnt = pw_cnt;
4430
4431 pws_cnt++;
4432
4433 device_param->pws_cnt = pws_cnt;
4434
4435 if (pws_cnt == device_param->kernel_power_user) break;
4436 }
4437
4438 const uint pw_cnt = device_param->pw_cnt;
4439 const uint pws_cnt = device_param->pws_cnt;
4440
4441 if (pws_cnt)
4442 {
4443 run_copy (device_param, pws_cnt);
4444
4445 run_cracker (device_param, pw_cnt, pws_cnt);
4446
4447 device_param->pw_cnt = 0;
4448 device_param->pws_cnt = 0;
4449 }
4450
4451 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4452
4453 if (data.devices_status == STATUS_CRACKED) break;
4454 if (data.devices_status == STATUS_ABORTED) break;
4455 if (data.devices_status == STATUS_QUIT) break;
4456 if (data.devices_status == STATUS_BYPASS) break;
4457 }
4458
4459 //
4460 // flush session 2
4461 //
4462
4463 {
4464 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4465 {
4466 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4467
4468 const uint pw_cache_cnt = pw_cache->cnt;
4469
4470 if (pw_cache_cnt == 0) continue;
4471
4472 pw_cache->cnt = 0;
4473
4474 uint pws_cnt = device_param->pws_cnt;
4475
4476 pw_t *pw = device_param->pws_buf + pws_cnt;
4477
4478 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4479
4480 pw->pw_len = pw_len;
4481
4482 uint pw_cnt = device_param->pw_cnt;
4483
4484 pw_cnt += pw_cache_cnt;
4485
4486 device_param->pw_cnt = pw_cnt;
4487
4488 pws_cnt++;
4489
4490 device_param->pws_cnt = pws_cnt;
4491 }
4492
4493 const uint pw_cnt = device_param->pw_cnt;
4494 const uint pws_cnt = device_param->pws_cnt;
4495
4496 if (pws_cnt)
4497 {
4498 run_copy (device_param, pws_cnt);
4499
4500 run_cracker (device_param, pw_cnt, pws_cnt);
4501
4502 device_param->pw_cnt = 0;
4503 device_param->pws_cnt = 0;
4504 }
4505
4506 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4507
4508 if (data.devices_status == STATUS_CRACKED) break;
4509 if (data.devices_status == STATUS_ABORTED) break;
4510 if (data.devices_status == STATUS_QUIT) break;
4511 if (data.devices_status == STATUS_BYPASS) break;
4512 }
4513
4514 if (words_fin == 0) break;
4515
4516 device_param->words_done = words_fin;
4517 }
4518
4519 if (attack_mode == ATTACK_MODE_COMBI)
4520 {
4521 fclose (device_param->combs_fp);
4522 }
4523
4524 free (wl_data->buf);
4525 free (wl_data);
4526
4527 fclose (fd);
4528 }
4529
4530 return NULL;
4531 }
4532
4533 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4534 {
4535 salt_t *salt_buf = &data.salts_buf[salt_pos];
4536
4537 device_param->kernel_params_buf32[24] = salt_pos;
4538 device_param->kernel_params_buf32[27] = 1;
4539 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4540 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4541 device_param->kernel_params_buf32[30] = 0;
4542 device_param->kernel_params_buf32[31] = 1;
4543
4544 char *dictfile_old = data.dictfile;
4545 char *dictfile2_old = data.dictfile2;
4546 char *mask_old = data.mask;
4547
4548 const char *weak_hash_check = "weak-hash-check";
4549
4550 data.dictfile = (char *) weak_hash_check;
4551 data.dictfile2 = (char *) weak_hash_check;
4552 data.mask = (char *) weak_hash_check;
4553
4554 /**
4555 * run the kernel
4556 */
4557
4558 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4559 {
4560 run_kernel (KERN_RUN_1, device_param, 1);
4561 }
4562 else
4563 {
4564 run_kernel (KERN_RUN_1, device_param, 1);
4565
4566 const uint iter = salt_buf->salt_iter;
4567
4568 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4569 {
4570 uint loop_left = iter - loop_pos;
4571
4572 loop_left = MIN (loop_left, kernel_loops);
4573
4574 device_param->kernel_params_buf32[25] = loop_pos;
4575 device_param->kernel_params_buf32[26] = loop_left;
4576
4577 run_kernel (KERN_RUN_2, device_param, 1);
4578 }
4579
4580 run_kernel (KERN_RUN_3, device_param, 1);
4581 }
4582
4583 /**
4584 * result
4585 */
4586
4587 check_cracked (device_param, salt_pos);
4588
4589 /**
4590 * cleanup
4591 */
4592
4593 device_param->kernel_params_buf32[24] = 0;
4594 device_param->kernel_params_buf32[25] = 0;
4595 device_param->kernel_params_buf32[26] = 0;
4596 device_param->kernel_params_buf32[27] = 0;
4597 device_param->kernel_params_buf32[28] = 0;
4598 device_param->kernel_params_buf32[29] = 0;
4599 device_param->kernel_params_buf32[30] = 0;
4600 device_param->kernel_params_buf32[31] = 0;
4601
4602 data.dictfile = dictfile_old;
4603 data.dictfile2 = dictfile2_old;
4604 data.mask = mask_old;
4605 }
4606
4607 // hlfmt hashcat
4608
4609 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4610 {
4611 if (data.username == 0)
4612 {
4613 *hashbuf_pos = line_buf;
4614 *hashbuf_len = line_len;
4615 }
4616 else
4617 {
4618 char *pos = line_buf;
4619 int len = line_len;
4620
4621 for (int i = 0; i < line_len; i++, pos++, len--)
4622 {
4623 if (line_buf[i] == data.separator)
4624 {
4625 pos++;
4626
4627 len--;
4628
4629 break;
4630 }
4631 }
4632
4633 *hashbuf_pos = pos;
4634 *hashbuf_len = len;
4635 }
4636 }
4637
4638 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4639 {
4640 char *pos = NULL;
4641 int len = 0;
4642
4643 int sep_cnt = 0;
4644
4645 for (int i = 0; i < line_len; i++)
4646 {
4647 if (line_buf[i] == data.separator)
4648 {
4649 sep_cnt++;
4650
4651 continue;
4652 }
4653
4654 if (sep_cnt == 0)
4655 {
4656 if (pos == NULL) pos = line_buf + i;
4657
4658 len++;
4659 }
4660 }
4661
4662 *userbuf_pos = pos;
4663 *userbuf_len = len;
4664 }
4665
4666 // hlfmt pwdump
4667
4668 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4669 {
4670 int sep_cnt = 0;
4671
4672 int sep2_len = 0;
4673 int sep3_len = 0;
4674
4675 for (int i = 0; i < line_len; i++)
4676 {
4677 if (line_buf[i] == ':')
4678 {
4679 sep_cnt++;
4680
4681 continue;
4682 }
4683
4684 if (sep_cnt == 2) sep2_len++;
4685 if (sep_cnt == 3) sep3_len++;
4686 }
4687
4688 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4689
4690 return 0;
4691 }
4692
4693 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4694 {
4695 char *pos = NULL;
4696 int len = 0;
4697
4698 int sep_cnt = 0;
4699
4700 for (int i = 0; i < line_len; i++)
4701 {
4702 if (line_buf[i] == ':')
4703 {
4704 sep_cnt++;
4705
4706 continue;
4707 }
4708
4709 if (data.hash_mode == 1000)
4710 {
4711 if (sep_cnt == 3)
4712 {
4713 if (pos == NULL) pos = line_buf + i;
4714
4715 len++;
4716 }
4717 }
4718 else if (data.hash_mode == 3000)
4719 {
4720 if (sep_cnt == 2)
4721 {
4722 if (pos == NULL) pos = line_buf + i;
4723
4724 len++;
4725 }
4726 }
4727 }
4728
4729 *hashbuf_pos = pos;
4730 *hashbuf_len = len;
4731 }
4732
4733 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4734 {
4735 char *pos = NULL;
4736 int len = 0;
4737
4738 int sep_cnt = 0;
4739
4740 for (int i = 0; i < line_len; i++)
4741 {
4742 if (line_buf[i] == ':')
4743 {
4744 sep_cnt++;
4745
4746 continue;
4747 }
4748
4749 if (sep_cnt == 0)
4750 {
4751 if (pos == NULL) pos = line_buf + i;
4752
4753 len++;
4754 }
4755 }
4756
4757 *userbuf_pos = pos;
4758 *userbuf_len = len;
4759 }
4760
4761 // hlfmt passwd
4762
4763 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4764 {
4765 int sep_cnt = 0;
4766
4767 char sep5_first = 0;
4768 char sep6_first = 0;
4769
4770 for (int i = 0; i < line_len; i++)
4771 {
4772 if (line_buf[i] == ':')
4773 {
4774 sep_cnt++;
4775
4776 continue;
4777 }
4778
4779 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4780 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4781 }
4782
4783 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4784
4785 return 0;
4786 }
4787
4788 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4789 {
4790 char *pos = NULL;
4791 int len = 0;
4792
4793 int sep_cnt = 0;
4794
4795 for (int i = 0; i < line_len; i++)
4796 {
4797 if (line_buf[i] == ':')
4798 {
4799 sep_cnt++;
4800
4801 continue;
4802 }
4803
4804 if (sep_cnt == 1)
4805 {
4806 if (pos == NULL) pos = line_buf + i;
4807
4808 len++;
4809 }
4810 }
4811
4812 *hashbuf_pos = pos;
4813 *hashbuf_len = len;
4814 }
4815
4816 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4817 {
4818 char *pos = NULL;
4819 int len = 0;
4820
4821 int sep_cnt = 0;
4822
4823 for (int i = 0; i < line_len; i++)
4824 {
4825 if (line_buf[i] == ':')
4826 {
4827 sep_cnt++;
4828
4829 continue;
4830 }
4831
4832 if (sep_cnt == 0)
4833 {
4834 if (pos == NULL) pos = line_buf + i;
4835
4836 len++;
4837 }
4838 }
4839
4840 *userbuf_pos = pos;
4841 *userbuf_len = len;
4842 }
4843
4844 // hlfmt shadow
4845
4846 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4847 {
4848 int sep_cnt = 0;
4849
4850 for (int i = 0; i < line_len; i++)
4851 {
4852 if (line_buf[i] == ':') sep_cnt++;
4853 }
4854
4855 if (sep_cnt == 8) return 1;
4856
4857 return 0;
4858 }
4859
4860 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4861 {
4862 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4863 }
4864
4865 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4866 {
4867 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4868 }
4869
4870 // hlfmt main
4871
4872 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4873 {
4874 switch (hashfile_format)
4875 {
4876 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4877 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4878 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4879 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4880 }
4881 }
4882
4883 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4884 {
4885 switch (hashfile_format)
4886 {
4887 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4888 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4889 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4890 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4891 }
4892 }
4893
4894 static uint hlfmt_detect (FILE *fp, uint max_check)
4895 {
4896 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4897
4898 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4899 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4900
4901 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4902
4903 uint num_check = 0;
4904
4905 while (!feof (fp))
4906 {
4907 char line_buf[BUFSIZ];
4908
4909 int line_len = fgetl (fp, line_buf);
4910
4911 if (line_len == 0) continue;
4912
4913 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4914 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4915 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4916
4917 if (num_check == max_check) break;
4918
4919 num_check++;
4920 }
4921
4922 uint hashlist_format = HLFMT_HASHCAT;
4923
4924 for (int i = 1; i < HLFMTS_CNT; i++)
4925 {
4926 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4927
4928 hashlist_format = i;
4929 }
4930
4931 free (formats_cnt);
4932
4933 return hashlist_format;
4934 }
4935
4936 /**
4937 * some further helper function
4938 */
4939
4940 // wrapper around mymalloc for ADL
4941
4942 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4943 {
4944 return mymalloc (iSize);
4945 }
4946
4947 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const uint64_t collisions_max)
4948 {
4949 uint64_t collisions = 0;
4950
4951 const uint dgst_pos0 = data.dgst_pos0;
4952 const uint dgst_pos1 = data.dgst_pos1;
4953 const uint dgst_pos2 = data.dgst_pos2;
4954 const uint dgst_pos3 = data.dgst_pos3;
4955
4956 memset (bitmap_a, 0, bitmap_size);
4957 memset (bitmap_b, 0, bitmap_size);
4958 memset (bitmap_c, 0, bitmap_size);
4959 memset (bitmap_d, 0, bitmap_size);
4960
4961 for (uint i = 0; i < digests_cnt; i++)
4962 {
4963 uint *digest_ptr = (uint *) digests_buf_ptr;
4964
4965 digests_buf_ptr += dgst_size;
4966
4967 const uint val0 = 1 << (digest_ptr[dgst_pos0] & 0x1f);
4968 const uint val1 = 1 << (digest_ptr[dgst_pos1] & 0x1f);
4969 const uint val2 = 1 << (digest_ptr[dgst_pos2] & 0x1f);
4970 const uint val3 = 1 << (digest_ptr[dgst_pos3] & 0x1f);
4971
4972 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4973 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4974 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4975 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4976
4977 if (bitmap_a[idx0] & val0) collisions++;
4978 if (bitmap_b[idx1] & val1) collisions++;
4979 if (bitmap_c[idx2] & val2) collisions++;
4980 if (bitmap_d[idx3] & val3) collisions++;
4981
4982 bitmap_a[idx0] |= val0;
4983 bitmap_b[idx1] |= val1;
4984 bitmap_c[idx2] |= val2;
4985 bitmap_d[idx3] |= val3;
4986
4987 if (collisions >= collisions_max) return 0x7fffffff;
4988 }
4989
4990 return collisions;
4991 }
4992
4993 /**
4994 * main
4995 */
4996
4997 int main (int argc, char **argv)
4998 {
4999 /**
5000 * To help users a bit
5001 */
5002
5003 char *compute = getenv ("COMPUTE");
5004
5005 if (compute)
5006 {
5007 char display[100];
5008
5009 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5010
5011 putenv (display);
5012 }
5013 else
5014 {
5015 if (getenv ("DISPLAY") == NULL)
5016 putenv ((char *) "DISPLAY=:0");
5017 }
5018
5019 /*
5020 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5021 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5022
5023 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5024 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5025 */
5026
5027 /**
5028 * Real init
5029 */
5030
5031 memset (&data, 0, sizeof (hc_global_data_t));
5032
5033 time_t proc_start;
5034
5035 time (&proc_start);
5036
5037 data.proc_start = proc_start;
5038
5039 int myargc = argc;
5040 char **myargv = argv;
5041
5042 hc_thread_mutex_init (mux_dispatcher);
5043 hc_thread_mutex_init (mux_counter);
5044 hc_thread_mutex_init (mux_display);
5045 hc_thread_mutex_init (mux_adl);
5046
5047 /**
5048 * commandline parameters
5049 */
5050
5051 uint usage = USAGE;
5052 uint version = VERSION;
5053 uint quiet = QUIET;
5054 uint benchmark = BENCHMARK;
5055 uint benchmark_mode = BENCHMARK_MODE;
5056 uint show = SHOW;
5057 uint left = LEFT;
5058 uint username = USERNAME;
5059 uint remove = REMOVE;
5060 uint remove_timer = REMOVE_TIMER;
5061 uint64_t skip = SKIP;
5062 uint64_t limit = LIMIT;
5063 uint keyspace = KEYSPACE;
5064 uint potfile_disable = POTFILE_DISABLE;
5065 uint debug_mode = DEBUG_MODE;
5066 char *debug_file = NULL;
5067 char *induction_dir = NULL;
5068 char *outfile_check_dir = NULL;
5069 uint force = FORCE;
5070 uint runtime = RUNTIME;
5071 uint hash_mode = HASH_MODE;
5072 uint attack_mode = ATTACK_MODE;
5073 uint markov_disable = MARKOV_DISABLE;
5074 uint markov_classic = MARKOV_CLASSIC;
5075 uint markov_threshold = MARKOV_THRESHOLD;
5076 char *markov_hcstat = NULL;
5077 char *outfile = NULL;
5078 uint outfile_format = OUTFILE_FORMAT;
5079 uint outfile_autohex = OUTFILE_AUTOHEX;
5080 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5081 uint restore = RESTORE;
5082 uint restore_timer = RESTORE_TIMER;
5083 uint restore_disable = RESTORE_DISABLE;
5084 uint status = STATUS;
5085 uint status_timer = STATUS_TIMER;
5086 uint status_automat = STATUS_AUTOMAT;
5087 uint loopback = LOOPBACK;
5088 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5089 char *session = NULL;
5090 uint hex_charset = HEX_CHARSET;
5091 uint hex_salt = HEX_SALT;
5092 uint hex_wordlist = HEX_WORDLIST;
5093 uint rp_gen = RP_GEN;
5094 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5095 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5096 uint rp_gen_seed = RP_GEN_SEED;
5097 char *rule_buf_l = (char *) RULE_BUF_L;
5098 char *rule_buf_r = (char *) RULE_BUF_R;
5099 uint increment = INCREMENT;
5100 uint increment_min = INCREMENT_MIN;
5101 uint increment_max = INCREMENT_MAX;
5102 char *cpu_affinity = NULL;
5103 char *opencl_devices = NULL;
5104 char *opencl_platform = NULL;
5105 char *truecrypt_keyfiles = NULL;
5106 uint workload_profile = WORKLOAD_PROFILE;
5107 uint kernel_accel = KERNEL_ACCEL;
5108 uint kernel_loops = KERNEL_LOOPS;
5109 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5110 uint gpu_temp_abort = GPU_TEMP_ABORT;
5111 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5112 uint powertune_enable = POWERTUNE_ENABLE;
5113 uint logfile_disable = LOGFILE_DISABLE;
5114 uint segment_size = SEGMENT_SIZE;
5115 uint scrypt_tmto = SCRYPT_TMTO;
5116 char separator = SEPARATOR;
5117 uint bitmap_min = BITMAP_MIN;
5118 uint bitmap_max = BITMAP_MAX;
5119 char *custom_charset_1 = NULL;
5120 char *custom_charset_2 = NULL;
5121 char *custom_charset_3 = NULL;
5122 char *custom_charset_4 = NULL;
5123
5124 #define IDX_HELP 'h'
5125 #define IDX_VERSION 'V'
5126 #define IDX_VERSION_LOWER 'v'
5127 #define IDX_QUIET 0xff02
5128 #define IDX_SHOW 0xff03
5129 #define IDX_LEFT 0xff04
5130 #define IDX_REMOVE 0xff05
5131 #define IDX_REMOVE_TIMER 0xff37
5132 #define IDX_SKIP 's'
5133 #define IDX_LIMIT 'l'
5134 #define IDX_KEYSPACE 0xff35
5135 #define IDX_POTFILE_DISABLE 0xff06
5136 #define IDX_DEBUG_MODE 0xff43
5137 #define IDX_DEBUG_FILE 0xff44
5138 #define IDX_INDUCTION_DIR 0xff46
5139 #define IDX_OUTFILE_CHECK_DIR 0xff47
5140 #define IDX_USERNAME 0xff07
5141 #define IDX_FORCE 0xff08
5142 #define IDX_RUNTIME 0xff09
5143 #define IDX_BENCHMARK 'b'
5144 #define IDX_BENCHMARK_MODE 0xff32
5145 #define IDX_HASH_MODE 'm'
5146 #define IDX_ATTACK_MODE 'a'
5147 #define IDX_RP_FILE 'r'
5148 #define IDX_RP_GEN 'g'
5149 #define IDX_RP_GEN_FUNC_MIN 0xff10
5150 #define IDX_RP_GEN_FUNC_MAX 0xff11
5151 #define IDX_RP_GEN_SEED 0xff34
5152 #define IDX_RULE_BUF_L 'j'
5153 #define IDX_RULE_BUF_R 'k'
5154 #define IDX_INCREMENT 'i'
5155 #define IDX_INCREMENT_MIN 0xff12
5156 #define IDX_INCREMENT_MAX 0xff13
5157 #define IDX_OUTFILE 'o'
5158 #define IDX_OUTFILE_FORMAT 0xff14
5159 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5160 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5161 #define IDX_RESTORE 0xff15
5162 #define IDX_RESTORE_DISABLE 0xff27
5163 #define IDX_STATUS 0xff17
5164 #define IDX_STATUS_TIMER 0xff18
5165 #define IDX_STATUS_AUTOMAT 0xff50
5166 #define IDX_LOOPBACK 0xff38
5167 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5168 #define IDX_SESSION 0xff19
5169 #define IDX_HEX_CHARSET 0xff20
5170 #define IDX_HEX_SALT 0xff21
5171 #define IDX_HEX_WORDLIST 0xff40
5172 #define IDX_MARKOV_DISABLE 0xff22
5173 #define IDX_MARKOV_CLASSIC 0xff23
5174 #define IDX_MARKOV_THRESHOLD 't'
5175 #define IDX_MARKOV_HCSTAT 0xff24
5176 #define IDX_CPU_AFFINITY 0xff25
5177 #define IDX_OPENCL_DEVICES 'd'
5178 #define IDX_OPENCL_PLATFORM 0xff72
5179 #define IDX_WORKLOAD_PROFILE 'w'
5180 #define IDX_KERNEL_ACCEL 'n'
5181 #define IDX_KERNEL_LOOPS 'u'
5182 #define IDX_GPU_TEMP_DISABLE 0xff29
5183 #define IDX_GPU_TEMP_ABORT 0xff30
5184 #define IDX_GPU_TEMP_RETAIN 0xff31
5185 #define IDX_POWERTUNE_ENABLE 0xff41
5186 #define IDX_LOGFILE_DISABLE 0xff51
5187 #define IDX_TRUECRYPT_KEYFILES 0xff52
5188 #define IDX_SCRYPT_TMTO 0xff61
5189 #define IDX_SEGMENT_SIZE 'c'
5190 #define IDX_SEPARATOR 'p'
5191 #define IDX_BITMAP_MIN 0xff70
5192 #define IDX_BITMAP_MAX 0xff71
5193 #define IDX_CUSTOM_CHARSET_1 '1'
5194 #define IDX_CUSTOM_CHARSET_2 '2'
5195 #define IDX_CUSTOM_CHARSET_3 '3'
5196 #define IDX_CUSTOM_CHARSET_4 '4'
5197
5198 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5199
5200 struct option long_options[] =
5201 {
5202 {"help", no_argument, 0, IDX_HELP},
5203 {"version", no_argument, 0, IDX_VERSION},
5204 {"quiet", no_argument, 0, IDX_QUIET},
5205 {"show", no_argument, 0, IDX_SHOW},
5206 {"left", no_argument, 0, IDX_LEFT},
5207 {"username", no_argument, 0, IDX_USERNAME},
5208 {"remove", no_argument, 0, IDX_REMOVE},
5209 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5210 {"skip", required_argument, 0, IDX_SKIP},
5211 {"limit", required_argument, 0, IDX_LIMIT},
5212 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5213 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5214 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5215 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5216 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5217 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5218 {"force", no_argument, 0, IDX_FORCE},
5219 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5220 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5221 {"restore", no_argument, 0, IDX_RESTORE},
5222 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5223 {"status", no_argument, 0, IDX_STATUS},
5224 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5225 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5226 {"loopback", no_argument, 0, IDX_LOOPBACK},
5227 {"weak-hash-threshold",
5228 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5229 {"session", required_argument, 0, IDX_SESSION},
5230 {"runtime", required_argument, 0, IDX_RUNTIME},
5231 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5232 {"generate-rules-func-min",
5233 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5234 {"generate-rules-func-max",
5235 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5236 {"generate-rules-seed",
5237 required_argument, 0, IDX_RP_GEN_SEED},
5238 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5239 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5240 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5241 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5242 {"rules-file", required_argument, 0, IDX_RP_FILE},
5243 {"outfile", required_argument, 0, IDX_OUTFILE},
5244 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5245 {"outfile-autohex-disable",
5246 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5247 {"outfile-check-timer",
5248 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5249 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5250 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5251 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5252 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5253 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5254 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5255 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5256 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5257 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5258 {"opencl-platform", required_argument, 0, IDX_OPENCL_PLATFORM},
5259 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5260 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5261 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5262 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5263 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5264 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5265 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5266 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5267 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5268 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5269 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5270 // deprecated
5271 {"seperator", required_argument, 0, IDX_SEPARATOR},
5272 {"separator", required_argument, 0, IDX_SEPARATOR},
5273 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5274 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5275 {"increment", no_argument, 0, IDX_INCREMENT},
5276 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5277 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5278 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5279 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5280 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5281 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5282
5283 {0, 0, 0, 0}
5284 };
5285
5286 uint rp_files_cnt = 0;
5287
5288 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5289
5290 int option_index;
5291 int c;
5292
5293 optind = 1;
5294 optopt = 0;
5295 option_index = 0;
5296
5297 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5298 {
5299 switch (c)
5300 {
5301 case IDX_HELP: usage = 1; break;
5302 case IDX_VERSION:
5303 case IDX_VERSION_LOWER: version = 1; break;
5304 case IDX_RESTORE: restore = 1; break;
5305 case IDX_SESSION: session = optarg; break;
5306 case IDX_SHOW: show = 1; break;
5307 case IDX_LEFT: left = 1; break;
5308 case '?': return (-1);
5309 }
5310 }
5311
5312 if (optopt != 0)
5313 {
5314 log_error ("ERROR: Invalid argument specified");
5315
5316 return (-1);
5317 }
5318
5319 /**
5320 * exit functions
5321 */
5322
5323 if (version)
5324 {
5325 log_info (VERSION_TXT);
5326
5327 return (0);
5328 }
5329
5330 if (usage)
5331 {
5332 usage_big_print (PROGNAME);
5333
5334 return (0);
5335 }
5336
5337 /**
5338 * session needs to be set, always!
5339 */
5340
5341 if (session == NULL) session = (char *) PROGNAME;
5342
5343 /**
5344 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5345 */
5346
5347 char *exec_path = get_exec_path ();
5348
5349 #ifdef LINUX
5350
5351 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5352 char *resolved_exec_path = realpath (exec_path, NULL);
5353
5354 char *install_dir = get_install_dir (resolved_exec_path);
5355 char *profile_dir = NULL;
5356 char *session_dir = NULL;
5357 char *shared_dir = NULL;
5358
5359 if (strcmp (install_dir, resolved_install_folder) == 0)
5360 {
5361 struct passwd *pw = getpwuid (getuid ());
5362
5363 const char *homedir = pw->pw_dir;
5364
5365 profile_dir = get_profile_dir (homedir);
5366 session_dir = get_session_dir (profile_dir);
5367 shared_dir = strdup (SHARED_FOLDER);
5368
5369 mkdir (profile_dir, 0700);
5370 mkdir (session_dir, 0700);
5371 }
5372 else
5373 {
5374 profile_dir = install_dir;
5375 session_dir = install_dir;
5376 shared_dir = install_dir;
5377 }
5378
5379 myfree (resolved_install_folder);
5380 myfree (resolved_exec_path);
5381
5382 #else
5383
5384 char *install_dir = get_install_dir (exec_path);
5385 char *profile_dir = install_dir;
5386 char *session_dir = install_dir;
5387 char *shared_dir = install_dir;
5388
5389 #endif
5390
5391 data.install_dir = install_dir;
5392 data.profile_dir = profile_dir;
5393 data.session_dir = session_dir;
5394 data.shared_dir = shared_dir;
5395
5396 myfree (exec_path);
5397
5398 /**
5399 * session
5400 */
5401
5402 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5403
5404 data.session = session;
5405
5406 char *eff_restore_file = (char *) mymalloc (session_size);
5407 char *new_restore_file = (char *) mymalloc (session_size);
5408
5409 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5410 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5411
5412 data.eff_restore_file = eff_restore_file;
5413 data.new_restore_file = new_restore_file;
5414
5415 if (((show == 1) || (left == 1)) && (restore == 1))
5416 {
5417 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5418 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5419
5420 return (-1);
5421 }
5422
5423 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5424 if ((show == 1) || (left == 1))
5425 {
5426 restore_disable = 1;
5427
5428 restore = 0;
5429 }
5430
5431 data.restore_disable = restore_disable;
5432
5433 restore_data_t *rd = init_restore (argc, argv);
5434
5435 data.rd = rd;
5436
5437 /**
5438 * restore file
5439 */
5440
5441 if (restore == 1)
5442 {
5443 read_restore (eff_restore_file, rd);
5444
5445 if (rd->version_bin < RESTORE_MIN)
5446 {
5447 log_error ("ERROR: Incompatible restore-file version");
5448
5449 return (-1);
5450 }
5451
5452 myargc = rd->argc;
5453 myargv = rd->argv;
5454
5455 #ifdef _POSIX
5456 rd->pid = getpid ();
5457 #elif _WIN
5458 rd->pid = GetCurrentProcessId ();
5459 #endif
5460 }
5461
5462 uint hash_mode_chgd = 0;
5463 uint runtime_chgd = 0;
5464 uint kernel_loops_chgd = 0;
5465 uint kernel_accel_chgd = 0;
5466 uint attack_mode_chgd = 0;
5467 uint outfile_format_chgd = 0;
5468 uint rp_gen_seed_chgd = 0;
5469 uint remove_timer_chgd = 0;
5470 uint increment_min_chgd = 0;
5471 uint increment_max_chgd = 0;
5472 uint gpu_temp_abort_chgd = 0;
5473 uint gpu_temp_retain_chgd = 0;
5474
5475 optind = 1;
5476 optopt = 0;
5477 option_index = 0;
5478
5479 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5480 {
5481 switch (c)
5482 {
5483 //case IDX_HELP: usage = 1; break;
5484 //case IDX_VERSION: version = 1; break;
5485 //case IDX_RESTORE: restore = 1; break;
5486 case IDX_QUIET: quiet = 1; break;
5487 //case IDX_SHOW: show = 1; break;
5488 case IDX_SHOW: break;
5489 //case IDX_LEFT: left = 1; break;
5490 case IDX_LEFT: break;
5491 case IDX_USERNAME: username = 1; break;
5492 case IDX_REMOVE: remove = 1; break;
5493 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5494 remove_timer_chgd = 1; break;
5495 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5496 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5497 case IDX_DEBUG_FILE: debug_file = optarg; break;
5498 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5499 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5500 case IDX_FORCE: force = 1; break;
5501 case IDX_SKIP: skip = atoll (optarg); break;
5502 case IDX_LIMIT: limit = atoll (optarg); break;
5503 case IDX_KEYSPACE: keyspace = 1; break;
5504 case IDX_BENCHMARK: benchmark = 1; break;
5505 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5506 case IDX_RESTORE: break;
5507 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5508 case IDX_STATUS: status = 1; break;
5509 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5510 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5511 case IDX_LOOPBACK: loopback = 1; break;
5512 case IDX_WEAK_HASH_THRESHOLD:
5513 weak_hash_threshold = atoi (optarg); break;
5514 //case IDX_SESSION: session = optarg; break;
5515 case IDX_SESSION: break;
5516 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5517 hash_mode_chgd = 1; break;
5518 case IDX_RUNTIME: runtime = atoi (optarg);
5519 runtime_chgd = 1; break;
5520 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5521 attack_mode_chgd = 1; break;
5522 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5523 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5524 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5525 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5526 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5527 rp_gen_seed_chgd = 1; break;
5528 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5529 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5530 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5531 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5532 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5533 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5534 case IDX_OUTFILE: outfile = optarg; break;
5535 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5536 outfile_format_chgd = 1; break;
5537 case IDX_OUTFILE_AUTOHEX_DISABLE:
5538 outfile_autohex = 0; break;
5539 case IDX_OUTFILE_CHECK_TIMER:
5540 outfile_check_timer = atoi (optarg); break;
5541 case IDX_HEX_CHARSET: hex_charset = 1; break;
5542 case IDX_HEX_SALT: hex_salt = 1; break;
5543 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5544 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5545 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5546 case IDX_OPENCL_PLATFORM: opencl_platform = optarg; break;
5547 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5548 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5549 kernel_accel_chgd = 1; break;
5550 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5551 kernel_loops_chgd = 1; break;
5552 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5553 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5554 gpu_temp_abort = atoi (optarg); break;
5555 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5556 gpu_temp_retain = atoi (optarg); break;
5557 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5558 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5559 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5560 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5561 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5562 case IDX_SEPARATOR: separator = optarg[0]; break;
5563 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5564 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5565 case IDX_INCREMENT: increment = 1; break;
5566 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5567 increment_min_chgd = 1; break;
5568 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5569 increment_max_chgd = 1; break;
5570 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5571 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5572 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5573 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5574
5575 default:
5576 log_error ("ERROR: Invalid argument specified");
5577 return (-1);
5578 }
5579 }
5580
5581 if (optopt != 0)
5582 {
5583 log_error ("ERROR: Invalid argument specified");
5584
5585 return (-1);
5586 }
5587
5588 /**
5589 * Inform user things getting started,
5590 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5591 * - we do not need to check algorithm_pos
5592 */
5593
5594 if (quiet == 0)
5595 {
5596 if (benchmark == 1)
5597 {
5598 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5599
5600 log_info ("");
5601 }
5602 else if (restore == 1)
5603 {
5604 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5605
5606 log_info ("");
5607 }
5608 else
5609 {
5610 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5611
5612 log_info ("");
5613 }
5614 }
5615
5616 /**
5617 * sanity check
5618 */
5619
5620 if (attack_mode > 7)
5621 {
5622 log_error ("ERROR: Invalid attack-mode specified");
5623
5624 return (-1);
5625 }
5626
5627 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5628 {
5629 log_error ("ERROR: Invalid runtime specified");
5630
5631 return (-1);
5632 }
5633
5634 if (hash_mode_chgd && hash_mode > 12800) // just added to remove compiler warnings for hash_mode_chgd
5635 {
5636 log_error ("ERROR: Invalid hash-type specified");
5637
5638 return (-1);
5639 }
5640
5641 // renamed hash modes
5642
5643 if (hash_mode_chgd)
5644 {
5645 int n = -1;
5646
5647 switch (hash_mode)
5648 {
5649 case 123: n = 124;
5650 break;
5651 }
5652
5653 if (n >= 0)
5654 {
5655 log_error ("Old -m specified, use -m %d instead", n);
5656
5657 return (-1);
5658 }
5659 }
5660
5661 if (username == 1)
5662 {
5663 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5664 {
5665 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5666
5667 return (-1);
5668 }
5669 }
5670
5671 if (outfile_format > 16)
5672 {
5673 log_error ("ERROR: Invalid outfile-format specified");
5674
5675 return (-1);
5676 }
5677
5678 if (left == 1)
5679 {
5680 if (outfile_format_chgd == 1)
5681 {
5682 if (outfile_format > 1)
5683 {
5684 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5685
5686 return (-1);
5687 }
5688 }
5689 else
5690 {
5691 outfile_format = OUTFILE_FMT_HASH;
5692 }
5693 }
5694
5695 if (show == 1)
5696 {
5697 if (outfile_format_chgd == 1)
5698 {
5699 if ((outfile_format > 7) && (outfile_format < 16))
5700 {
5701 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5702
5703 return (-1);
5704 }
5705 }
5706 }
5707
5708 if (increment_min < INCREMENT_MIN)
5709 {
5710 log_error ("ERROR: Invalid increment-min specified");
5711
5712 return (-1);
5713 }
5714
5715 if (increment_max > INCREMENT_MAX)
5716 {
5717 log_error ("ERROR: Invalid increment-max specified");
5718
5719 return (-1);
5720 }
5721
5722 if (increment_min > increment_max)
5723 {
5724 log_error ("ERROR: Invalid increment-min specified");
5725
5726 return (-1);
5727 }
5728
5729 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5730 {
5731 log_error ("ERROR: increment is not allowed in attack-mode 0");
5732
5733 return (-1);
5734 }
5735
5736 if ((increment == 0) && (increment_min_chgd == 1))
5737 {
5738 log_error ("ERROR: increment-min is only supported together with increment switch");
5739
5740 return (-1);
5741 }
5742
5743 if ((increment == 0) && (increment_max_chgd == 1))
5744 {
5745 log_error ("ERROR: increment-max is only supported together with increment switch");
5746
5747 return (-1);
5748 }
5749
5750 if (rp_files_cnt && rp_gen)
5751 {
5752 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5753
5754 return (-1);
5755 }
5756
5757 if (rp_files_cnt || rp_gen)
5758 {
5759 if (attack_mode != ATTACK_MODE_STRAIGHT)
5760 {
5761 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5762
5763 return (-1);
5764 }
5765 }
5766
5767 if (rp_gen_func_min > rp_gen_func_max)
5768 {
5769 log_error ("ERROR: Invalid rp-gen-func-min specified");
5770
5771 return (-1);
5772 }
5773
5774 if (kernel_accel_chgd == 1)
5775 {
5776 if (workload_profile != WORKLOAD_PROFILE)
5777 {
5778 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5779
5780 return (-1);
5781 }
5782
5783 if (kernel_accel < 1)
5784 {
5785 log_error ("ERROR: Invalid kernel-accel specified");
5786
5787 return (-1);
5788 }
5789
5790 if (kernel_accel > 800)
5791 {
5792 log_error ("ERROR: Invalid kernel-accel specified");
5793
5794 return (-1);
5795 }
5796 }
5797
5798 if (kernel_loops_chgd == 1)
5799 {
5800 if (workload_profile != WORKLOAD_PROFILE)
5801 {
5802 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5803
5804 return (-1);
5805 }
5806
5807 if (kernel_loops < 1)
5808 {
5809 log_error ("ERROR: Invalid kernel-loops specified");
5810
5811 return (-1);
5812 }
5813
5814 if (kernel_loops > 1024)
5815 {
5816 log_error ("ERROR: Invalid kernel-loops specified");
5817
5818 return (-1);
5819 }
5820 }
5821
5822 if (benchmark == 1)
5823 {
5824 if (workload_profile != WORKLOAD_PROFILE)
5825 {
5826 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5827
5828 return (-1);
5829 }
5830 }
5831
5832 if ((workload_profile < 1) || (workload_profile > 3))
5833 {
5834 log_error ("ERROR: workload-profile %i not available", workload_profile);
5835
5836 return (-1);
5837 }
5838
5839 if (show == 1 || left == 1)
5840 {
5841 attack_mode = ATTACK_MODE_NONE;
5842
5843 if (remove == 1)
5844 {
5845 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5846
5847 return (-1);
5848 }
5849
5850 if (potfile_disable == 1)
5851 {
5852 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5853
5854 return (-1);
5855 }
5856 }
5857
5858 uint attack_kern = ATTACK_KERN_NONE;
5859
5860 switch (attack_mode)
5861 {
5862 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5863 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5864 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5865 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5866 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5867 }
5868
5869 if (benchmark == 0)
5870 {
5871 if (keyspace == 1)
5872 {
5873 int num_additional_params = 1;
5874
5875 if (attack_kern == ATTACK_KERN_COMBI)
5876 {
5877 num_additional_params = 2;
5878 }
5879
5880 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5881
5882 if (keyspace_wordlist_specified == 0) optind--;
5883 }
5884
5885 if (attack_kern == ATTACK_KERN_NONE)
5886 {
5887 if ((optind + 1) != myargc)
5888 {
5889 usage_mini_print (myargv[0]);
5890
5891 return (-1);
5892 }
5893 }
5894 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5895 {
5896 if ((optind + 1) > myargc)
5897 {
5898 usage_mini_print (myargv[0]);
5899
5900 return (-1);
5901 }
5902 }
5903 else if (attack_kern == ATTACK_KERN_COMBI)
5904 {
5905 if ((optind + 3) != myargc)
5906 {
5907 usage_mini_print (myargv[0]);
5908
5909 return (-1);
5910 }
5911 }
5912 else if (attack_kern == ATTACK_KERN_BF)
5913 {
5914 if ((optind + 1) > myargc)
5915 {
5916 usage_mini_print (myargv[0]);
5917
5918 return (-1);
5919 }
5920 }
5921 else
5922 {
5923 usage_mini_print (myargv[0]);
5924
5925 return (-1);
5926 }
5927 }
5928 else
5929 {
5930 if (myargv[optind] != 0)
5931 {
5932 log_error ("ERROR: Invalid argument for benchmark mode specified");
5933
5934 return (-1);
5935 }
5936
5937 if (attack_mode_chgd == 1)
5938 {
5939 if (attack_mode != ATTACK_MODE_BF)
5940 {
5941 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5942
5943 return (-1);
5944 }
5945 }
5946
5947 if (benchmark_mode == 0)
5948 {
5949 // nothing to do
5950 }
5951 else if (benchmark_mode == 1)
5952 {
5953 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
5954 {
5955 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
5956
5957 return (-1);
5958 }
5959 }
5960 else
5961 {
5962 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5963
5964 return (-1);
5965 }
5966 }
5967
5968 if (skip != 0 && limit != 0)
5969 {
5970 limit += skip;
5971 }
5972
5973 if (keyspace == 1)
5974 {
5975 if (show == 1)
5976 {
5977 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
5978
5979 return (-1);
5980 }
5981 else if (left == 1)
5982 {
5983 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
5984
5985 return (-1);
5986 }
5987
5988 potfile_disable = 1;
5989
5990 restore_disable = 1;
5991
5992 restore = 0;
5993
5994 weak_hash_threshold = 0;
5995
5996 quiet = 1;
5997 }
5998
5999 if (remove_timer_chgd == 1)
6000 {
6001 if (remove == 0)
6002 {
6003 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6004
6005 return (-1);
6006 }
6007
6008 if (remove_timer < 1)
6009 {
6010 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6011
6012 return (-1);
6013 }
6014 }
6015
6016 if (loopback == 1)
6017 {
6018 if (attack_mode == ATTACK_MODE_BF)
6019 {
6020 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6021
6022 return (-1);
6023 }
6024 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6025 {
6026 if ((rp_files_cnt == 0) && (rp_gen == 0))
6027 {
6028 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6029
6030 return (-1);
6031 }
6032 }
6033 }
6034
6035 if (debug_mode > 0)
6036 {
6037 if (attack_mode != ATTACK_MODE_STRAIGHT)
6038 {
6039 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6040
6041 return (-1);
6042 }
6043
6044 if ((rp_files_cnt == 0) && (rp_gen == 0))
6045 {
6046 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6047
6048 return (-1);
6049 }
6050 }
6051
6052 if (debug_mode > 4)
6053 {
6054 log_error ("ERROR: Invalid debug-mode specified");
6055
6056 return (-1);
6057 }
6058
6059 if (debug_file != NULL)
6060 {
6061 if (debug_mode < 1)
6062 {
6063 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6064
6065 return (-1);
6066 }
6067 }
6068
6069 if (induction_dir != NULL)
6070 {
6071 if (attack_mode == ATTACK_MODE_BF)
6072 {
6073 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6074
6075 return (-1);
6076 }
6077 }
6078
6079 /**
6080 * induction directory
6081 */
6082
6083 char *induction_directory = NULL;
6084
6085 if (attack_mode != ATTACK_MODE_BF)
6086 {
6087 if (induction_dir == NULL)
6088 {
6089 induction_directory = (char *) mymalloc (session_size);
6090
6091 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6092
6093 // create induction folder if it does not already exist
6094
6095 if (keyspace == 0)
6096 {
6097 if (rmdir (induction_directory) == -1)
6098 {
6099 if (errno == ENOENT)
6100 {
6101 // good, we can ignore
6102 }
6103 else if (errno == ENOTEMPTY)
6104 {
6105 char *induction_directory_mv = (char *) mymalloc (session_size);
6106
6107 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6108
6109 if (rename (induction_directory, induction_directory_mv) != 0)
6110 {
6111 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6112
6113 return (-1);
6114 }
6115 }
6116 else
6117 {
6118 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6119
6120 return (-1);
6121 }
6122 }
6123
6124 if (mkdir (induction_directory, 0700) == -1)
6125 {
6126 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6127
6128 return (-1);
6129 }
6130 }
6131 }
6132 else
6133 {
6134 induction_directory = induction_dir;
6135 }
6136 }
6137
6138 data.induction_directory = induction_directory;
6139
6140 /**
6141 * loopback
6142 */
6143
6144 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6145
6146 char *loopback_file = (char *) mymalloc (loopback_size);
6147
6148 /**
6149 * outfile-check directory
6150 */
6151
6152 char *outfile_check_directory = NULL;
6153
6154 if (outfile_check_dir == NULL)
6155 {
6156 outfile_check_directory = (char *) mymalloc (session_size);
6157
6158 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6159 }
6160 else
6161 {
6162 outfile_check_directory = outfile_check_dir;
6163 }
6164
6165 data.outfile_check_directory = outfile_check_directory;
6166
6167 if (keyspace == 0)
6168 {
6169 struct stat outfile_check_stat;
6170
6171 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6172 {
6173 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6174
6175 if (is_dir == 0)
6176 {
6177 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6178
6179 return (-1);
6180 }
6181 }
6182 else if (outfile_check_dir == NULL)
6183 {
6184 if (mkdir (outfile_check_directory, 0700) == -1)
6185 {
6186 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6187
6188 return (-1);
6189 }
6190 }
6191 }
6192
6193 /**
6194 * special other stuff
6195 */
6196
6197 if (hash_mode == 9710)
6198 {
6199 outfile_format = 5;
6200 outfile_format_chgd = 1;
6201 }
6202
6203 if (hash_mode == 9810)
6204 {
6205 outfile_format = 5;
6206 outfile_format_chgd = 1;
6207 }
6208
6209 if (hash_mode == 10410)
6210 {
6211 outfile_format = 5;
6212 outfile_format_chgd = 1;
6213 }
6214
6215 /**
6216 * store stuff
6217 */
6218
6219 data.hash_mode = hash_mode;
6220 data.restore = restore;
6221 data.restore_timer = restore_timer;
6222 data.restore_disable = restore_disable;
6223 data.status = status;
6224 data.status_timer = status_timer;
6225 data.status_automat = status_automat;
6226 data.loopback = loopback;
6227 data.runtime = runtime;
6228 data.remove = remove;
6229 data.remove_timer = remove_timer;
6230 data.debug_mode = debug_mode;
6231 data.debug_file = debug_file;
6232 data.username = username;
6233 data.quiet = quiet;
6234 data.outfile = outfile;
6235 data.outfile_format = outfile_format;
6236 data.outfile_autohex = outfile_autohex;
6237 data.hex_charset = hex_charset;
6238 data.hex_salt = hex_salt;
6239 data.hex_wordlist = hex_wordlist;
6240 data.separator = separator;
6241 data.rp_files = rp_files;
6242 data.rp_files_cnt = rp_files_cnt;
6243 data.rp_gen = rp_gen;
6244 data.rp_gen_seed = rp_gen_seed;
6245 data.force = force;
6246 data.benchmark = benchmark;
6247 data.skip = skip;
6248 data.limit = limit;
6249 data.powertune_enable = powertune_enable;
6250 data.logfile_disable = logfile_disable;
6251 data.truecrypt_keyfiles = truecrypt_keyfiles;
6252 data.scrypt_tmto = scrypt_tmto;
6253
6254 /**
6255 * cpu affinity
6256 */
6257
6258 if (cpu_affinity)
6259 {
6260 set_cpu_affinity (cpu_affinity);
6261 }
6262
6263 if (rp_gen_seed_chgd == 0)
6264 {
6265 srand (proc_start);
6266 }
6267 else
6268 {
6269 srand (rp_gen_seed);
6270 }
6271
6272 /**
6273 * logfile init
6274 */
6275
6276 if (logfile_disable == 0)
6277 {
6278 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6279
6280 char *logfile = (char *) mymalloc (logfile_size);
6281
6282 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6283
6284 data.logfile = logfile;
6285
6286 char *topid = logfile_generate_topid ();
6287
6288 data.topid = topid;
6289 }
6290
6291 // logfile_append() checks for logfile_disable internally to make it easier from here
6292
6293 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6294 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6295 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6296 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6297 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6298 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6299 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6300 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6301 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6302 #define logfile_sub_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s\t%s", data.topid, data.subid, (var), (val));
6303
6304 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6305 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6306 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6307 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6308 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6309 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6310 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6311 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6312
6313 logfile_top_msg ("START");
6314
6315 logfile_top_uint (attack_mode);
6316 logfile_top_uint (attack_kern);
6317 logfile_top_uint (benchmark);
6318 logfile_top_uint (benchmark_mode);
6319 logfile_top_uint (bitmap_min);
6320 logfile_top_uint (bitmap_max);
6321 logfile_top_uint (debug_mode);
6322 logfile_top_uint (force);
6323 logfile_top_uint (kernel_accel);
6324 logfile_top_uint (kernel_loops);
6325 logfile_top_uint (gpu_temp_abort);
6326 logfile_top_uint (gpu_temp_disable);
6327 logfile_top_uint (gpu_temp_retain);
6328 logfile_top_uint (hash_mode);
6329 logfile_top_uint (hex_charset);
6330 logfile_top_uint (hex_salt);
6331 logfile_top_uint (hex_wordlist);
6332 logfile_top_uint (increment);
6333 logfile_top_uint (increment_max);
6334 logfile_top_uint (increment_min);
6335 logfile_top_uint (keyspace);
6336 logfile_top_uint (left);
6337 logfile_top_uint (logfile_disable);
6338 logfile_top_uint (loopback);
6339 logfile_top_uint (markov_classic);
6340 logfile_top_uint (markov_disable);
6341 logfile_top_uint (markov_threshold);
6342 logfile_top_uint (outfile_autohex);
6343 logfile_top_uint (outfile_check_timer);
6344 logfile_top_uint (outfile_format);
6345 logfile_top_uint (potfile_disable);
6346 logfile_top_uint (powertune_enable);
6347 logfile_top_uint (scrypt_tmto);
6348 logfile_top_uint (quiet);
6349 logfile_top_uint (remove);
6350 logfile_top_uint (remove_timer);
6351 logfile_top_uint (restore);
6352 logfile_top_uint (restore_disable);
6353 logfile_top_uint (restore_timer);
6354 logfile_top_uint (rp_gen);
6355 logfile_top_uint (rp_gen_func_max);
6356 logfile_top_uint (rp_gen_func_min);
6357 logfile_top_uint (rp_gen_seed);
6358 logfile_top_uint (runtime);
6359 logfile_top_uint (segment_size);
6360 logfile_top_uint (show);
6361 logfile_top_uint (status);
6362 logfile_top_uint (status_automat);
6363 logfile_top_uint (status_timer);
6364 logfile_top_uint (usage);
6365 logfile_top_uint (username);
6366 logfile_top_uint (version);
6367 logfile_top_uint (weak_hash_threshold);
6368 logfile_top_uint (workload_profile);
6369 logfile_top_uint64 (limit);
6370 logfile_top_uint64 (skip);
6371 logfile_top_char (separator);
6372 logfile_top_string (cpu_affinity);
6373 logfile_top_string (custom_charset_1);
6374 logfile_top_string (custom_charset_2);
6375 logfile_top_string (custom_charset_3);
6376 logfile_top_string (custom_charset_4);
6377 logfile_top_string (debug_file);
6378 logfile_top_string (opencl_devices);
6379 logfile_top_string (opencl_platform);
6380 logfile_top_string (induction_dir);
6381 logfile_top_string (markov_hcstat);
6382 logfile_top_string (outfile);
6383 logfile_top_string (outfile_check_dir);
6384 logfile_top_string (rule_buf_l);
6385 logfile_top_string (rule_buf_r);
6386 logfile_top_string (session);
6387 logfile_top_string (truecrypt_keyfiles);
6388
6389 /**
6390 * devices
6391 */
6392
6393 uint opencl_devicemask = devices_to_devicemask (opencl_devices);
6394
6395 /**
6396 * benchmark
6397 */
6398
6399 if (benchmark == 1)
6400 {
6401 /**
6402 * disable useless stuff for benchmark
6403 */
6404
6405 restore_timer = 0;
6406 status_timer = 0;
6407 restore_disable = 1;
6408 potfile_disable = 1;
6409 weak_hash_threshold = 0;
6410
6411 data.restore_timer = restore_timer;
6412 data.status_timer = status_timer;
6413 data.restore_disable = restore_disable;
6414
6415 if (benchmark_mode == 1)
6416 {
6417 markov_disable = 1;
6418 }
6419
6420 /**
6421 * force attack mode to be bruteforce
6422 */
6423
6424 attack_mode = ATTACK_MODE_BF;
6425 attack_kern = ATTACK_KERN_BF;
6426
6427 if (runtime_chgd == 0)
6428 {
6429 runtime = 4;
6430
6431 if (benchmark_mode == 1) runtime = 17;
6432
6433 data.runtime = runtime;
6434 }
6435 }
6436
6437 /**
6438 * config
6439 */
6440
6441 uint hash_type = 0;
6442 uint salt_type = 0;
6443 uint attack_exec = 0;
6444 uint opts_type = 0;
6445 uint kern_type = 0;
6446 uint dgst_size = 0;
6447 uint esalt_size = 0;
6448 uint opti_type = 0;
6449 uint dgst_pos0 = -1;
6450 uint dgst_pos1 = -1;
6451 uint dgst_pos2 = -1;
6452 uint dgst_pos3 = -1;
6453
6454 int (*parse_func) (char *, uint, hash_t *);
6455 int (*sort_by_digest) (const void *, const void *);
6456
6457 uint algorithm_pos = 0;
6458 uint algorithm_max = 1;
6459
6460 uint *algorithms = default_benchmark_algorithms;
6461
6462 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6463
6464 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6465 {
6466 /*
6467 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6468 * the following algos are skipped entirely
6469 */
6470
6471 if (algorithm_pos > 0)
6472 {
6473 local_free (rd);
6474
6475 rd = init_restore (argc, argv);
6476
6477 data.rd = rd;
6478 }
6479
6480 /**
6481 * update hash_mode in case of multihash benchmark
6482 */
6483
6484 if (benchmark == 1)
6485 {
6486 if (hash_mode_chgd == 0)
6487 {
6488 hash_mode = algorithms[algorithm_pos];
6489
6490 data.hash_mode = hash_mode;
6491 }
6492
6493 quiet = 1;
6494
6495 data.quiet = quiet;
6496 }
6497
6498 switch (hash_mode)
6499 {
6500 case 0: hash_type = HASH_TYPE_MD5;
6501 salt_type = SALT_TYPE_NONE;
6502 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6503 opts_type = OPTS_TYPE_PT_GENERATE_LE
6504 | OPTS_TYPE_PT_ADD80
6505 | OPTS_TYPE_PT_ADDBITS14;
6506 kern_type = KERN_TYPE_MD5;
6507 dgst_size = DGST_SIZE_4_4;
6508 parse_func = md5_parse_hash;
6509 sort_by_digest = sort_by_digest_4_4;
6510 opti_type = OPTI_TYPE_ZERO_BYTE
6511 | OPTI_TYPE_PRECOMPUTE_INIT
6512 | OPTI_TYPE_PRECOMPUTE_MERKLE
6513 | OPTI_TYPE_MEET_IN_MIDDLE
6514 | OPTI_TYPE_EARLY_SKIP
6515 | OPTI_TYPE_NOT_ITERATED
6516 | OPTI_TYPE_NOT_SALTED
6517 | OPTI_TYPE_RAW_HASH;
6518 dgst_pos0 = 0;
6519 dgst_pos1 = 3;
6520 dgst_pos2 = 2;
6521 dgst_pos3 = 1;
6522 break;
6523
6524 case 10: hash_type = HASH_TYPE_MD5;
6525 salt_type = SALT_TYPE_INTERN;
6526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6527 opts_type = OPTS_TYPE_PT_GENERATE_LE
6528 | OPTS_TYPE_ST_ADD80
6529 | OPTS_TYPE_ST_ADDBITS14;
6530 kern_type = KERN_TYPE_MD5_PWSLT;
6531 dgst_size = DGST_SIZE_4_4;
6532 parse_func = md5s_parse_hash;
6533 sort_by_digest = sort_by_digest_4_4;
6534 opti_type = OPTI_TYPE_ZERO_BYTE
6535 | OPTI_TYPE_PRECOMPUTE_INIT
6536 | OPTI_TYPE_PRECOMPUTE_MERKLE
6537 | OPTI_TYPE_MEET_IN_MIDDLE
6538 | OPTI_TYPE_EARLY_SKIP
6539 | OPTI_TYPE_NOT_ITERATED
6540 | OPTI_TYPE_APPENDED_SALT
6541 | OPTI_TYPE_RAW_HASH;
6542 dgst_pos0 = 0;
6543 dgst_pos1 = 3;
6544 dgst_pos2 = 2;
6545 dgst_pos3 = 1;
6546 break;
6547
6548 case 11: hash_type = HASH_TYPE_MD5;
6549 salt_type = SALT_TYPE_INTERN;
6550 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6551 opts_type = OPTS_TYPE_PT_GENERATE_LE
6552 | OPTS_TYPE_ST_ADD80
6553 | OPTS_TYPE_ST_ADDBITS14;
6554 kern_type = KERN_TYPE_MD5_PWSLT;
6555 dgst_size = DGST_SIZE_4_4;
6556 parse_func = joomla_parse_hash;
6557 sort_by_digest = sort_by_digest_4_4;
6558 opti_type = OPTI_TYPE_ZERO_BYTE
6559 | OPTI_TYPE_PRECOMPUTE_INIT
6560 | OPTI_TYPE_PRECOMPUTE_MERKLE
6561 | OPTI_TYPE_MEET_IN_MIDDLE
6562 | OPTI_TYPE_EARLY_SKIP
6563 | OPTI_TYPE_NOT_ITERATED
6564 | OPTI_TYPE_APPENDED_SALT
6565 | OPTI_TYPE_RAW_HASH;
6566 dgst_pos0 = 0;
6567 dgst_pos1 = 3;
6568 dgst_pos2 = 2;
6569 dgst_pos3 = 1;
6570 break;
6571
6572 case 12: hash_type = HASH_TYPE_MD5;
6573 salt_type = SALT_TYPE_INTERN;
6574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6575 opts_type = OPTS_TYPE_PT_GENERATE_LE
6576 | OPTS_TYPE_ST_ADD80
6577 | OPTS_TYPE_ST_ADDBITS14;
6578 kern_type = KERN_TYPE_MD5_PWSLT;
6579 dgst_size = DGST_SIZE_4_4;
6580 parse_func = postgresql_parse_hash;
6581 sort_by_digest = sort_by_digest_4_4;
6582 opti_type = OPTI_TYPE_ZERO_BYTE
6583 | OPTI_TYPE_PRECOMPUTE_INIT
6584 | OPTI_TYPE_PRECOMPUTE_MERKLE
6585 | OPTI_TYPE_MEET_IN_MIDDLE
6586 | OPTI_TYPE_EARLY_SKIP
6587 | OPTI_TYPE_NOT_ITERATED
6588 | OPTI_TYPE_APPENDED_SALT
6589 | OPTI_TYPE_RAW_HASH;
6590 dgst_pos0 = 0;
6591 dgst_pos1 = 3;
6592 dgst_pos2 = 2;
6593 dgst_pos3 = 1;
6594 break;
6595
6596 case 20: hash_type = HASH_TYPE_MD5;
6597 salt_type = SALT_TYPE_INTERN;
6598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6599 opts_type = OPTS_TYPE_PT_GENERATE_LE
6600 | OPTS_TYPE_PT_ADD80
6601 | OPTS_TYPE_PT_ADDBITS14;
6602 kern_type = KERN_TYPE_MD5_SLTPW;
6603 dgst_size = DGST_SIZE_4_4;
6604 parse_func = md5s_parse_hash;
6605 sort_by_digest = sort_by_digest_4_4;
6606 opti_type = OPTI_TYPE_ZERO_BYTE
6607 | OPTI_TYPE_PRECOMPUTE_INIT
6608 | OPTI_TYPE_PRECOMPUTE_MERKLE
6609 | OPTI_TYPE_EARLY_SKIP
6610 | OPTI_TYPE_NOT_ITERATED
6611 | OPTI_TYPE_PREPENDED_SALT
6612 | OPTI_TYPE_RAW_HASH;
6613 dgst_pos0 = 0;
6614 dgst_pos1 = 3;
6615 dgst_pos2 = 2;
6616 dgst_pos3 = 1;
6617 break;
6618
6619 case 21: hash_type = HASH_TYPE_MD5;
6620 salt_type = SALT_TYPE_INTERN;
6621 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6622 opts_type = OPTS_TYPE_PT_GENERATE_LE
6623 | OPTS_TYPE_PT_ADD80
6624 | OPTS_TYPE_PT_ADDBITS14;
6625 kern_type = KERN_TYPE_MD5_SLTPW;
6626 dgst_size = DGST_SIZE_4_4;
6627 parse_func = osc_parse_hash;
6628 sort_by_digest = sort_by_digest_4_4;
6629 opti_type = OPTI_TYPE_ZERO_BYTE
6630 | OPTI_TYPE_PRECOMPUTE_INIT
6631 | OPTI_TYPE_PRECOMPUTE_MERKLE
6632 | OPTI_TYPE_EARLY_SKIP
6633 | OPTI_TYPE_NOT_ITERATED
6634 | OPTI_TYPE_PREPENDED_SALT
6635 | OPTI_TYPE_RAW_HASH;
6636 dgst_pos0 = 0;
6637 dgst_pos1 = 3;
6638 dgst_pos2 = 2;
6639 dgst_pos3 = 1;
6640 break;
6641
6642 case 22: hash_type = HASH_TYPE_MD5;
6643 salt_type = SALT_TYPE_EMBEDDED;
6644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6645 opts_type = OPTS_TYPE_PT_GENERATE_LE
6646 | OPTS_TYPE_PT_ADD80
6647 | OPTS_TYPE_PT_ADDBITS14;
6648 kern_type = KERN_TYPE_MD5_SLTPW;
6649 dgst_size = DGST_SIZE_4_4;
6650 parse_func = netscreen_parse_hash;
6651 sort_by_digest = sort_by_digest_4_4;
6652 opti_type = OPTI_TYPE_ZERO_BYTE
6653 | OPTI_TYPE_PRECOMPUTE_INIT
6654 | OPTI_TYPE_PRECOMPUTE_MERKLE
6655 | OPTI_TYPE_EARLY_SKIP
6656 | OPTI_TYPE_NOT_ITERATED
6657 | OPTI_TYPE_PREPENDED_SALT
6658 | OPTI_TYPE_RAW_HASH;
6659 dgst_pos0 = 0;
6660 dgst_pos1 = 3;
6661 dgst_pos2 = 2;
6662 dgst_pos3 = 1;
6663 break;
6664
6665 case 23: hash_type = HASH_TYPE_MD5;
6666 salt_type = SALT_TYPE_EMBEDDED;
6667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6668 opts_type = OPTS_TYPE_PT_GENERATE_LE
6669 | OPTS_TYPE_PT_ADD80
6670 | OPTS_TYPE_PT_ADDBITS14;
6671 kern_type = KERN_TYPE_MD5_SLTPW;
6672 dgst_size = DGST_SIZE_4_4;
6673 parse_func = skype_parse_hash;
6674 sort_by_digest = sort_by_digest_4_4;
6675 opti_type = OPTI_TYPE_ZERO_BYTE
6676 | OPTI_TYPE_PRECOMPUTE_INIT
6677 | OPTI_TYPE_PRECOMPUTE_MERKLE
6678 | OPTI_TYPE_EARLY_SKIP
6679 | OPTI_TYPE_NOT_ITERATED
6680 | OPTI_TYPE_PREPENDED_SALT
6681 | OPTI_TYPE_RAW_HASH;
6682 dgst_pos0 = 0;
6683 dgst_pos1 = 3;
6684 dgst_pos2 = 2;
6685 dgst_pos3 = 1;
6686 break;
6687
6688 case 30: hash_type = HASH_TYPE_MD5;
6689 salt_type = SALT_TYPE_INTERN;
6690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6691 opts_type = OPTS_TYPE_PT_GENERATE_LE
6692 | OPTS_TYPE_PT_UNICODE
6693 | OPTS_TYPE_ST_ADD80
6694 | OPTS_TYPE_ST_ADDBITS14;
6695 kern_type = KERN_TYPE_MD5_PWUSLT;
6696 dgst_size = DGST_SIZE_4_4;
6697 parse_func = md5s_parse_hash;
6698 sort_by_digest = sort_by_digest_4_4;
6699 opti_type = OPTI_TYPE_ZERO_BYTE
6700 | OPTI_TYPE_PRECOMPUTE_INIT
6701 | OPTI_TYPE_PRECOMPUTE_MERKLE
6702 | OPTI_TYPE_MEET_IN_MIDDLE
6703 | OPTI_TYPE_EARLY_SKIP
6704 | OPTI_TYPE_NOT_ITERATED
6705 | OPTI_TYPE_APPENDED_SALT
6706 | OPTI_TYPE_RAW_HASH;
6707 dgst_pos0 = 0;
6708 dgst_pos1 = 3;
6709 dgst_pos2 = 2;
6710 dgst_pos3 = 1;
6711 break;
6712
6713 case 40: hash_type = HASH_TYPE_MD5;
6714 salt_type = SALT_TYPE_INTERN;
6715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6716 opts_type = OPTS_TYPE_PT_GENERATE_LE
6717 | OPTS_TYPE_PT_ADD80
6718 | OPTS_TYPE_PT_ADDBITS14
6719 | OPTS_TYPE_PT_UNICODE;
6720 kern_type = KERN_TYPE_MD5_SLTPWU;
6721 dgst_size = DGST_SIZE_4_4;
6722 parse_func = md5s_parse_hash;
6723 sort_by_digest = sort_by_digest_4_4;
6724 opti_type = OPTI_TYPE_ZERO_BYTE
6725 | OPTI_TYPE_PRECOMPUTE_INIT
6726 | OPTI_TYPE_PRECOMPUTE_MERKLE
6727 | OPTI_TYPE_EARLY_SKIP
6728 | OPTI_TYPE_NOT_ITERATED
6729 | OPTI_TYPE_PREPENDED_SALT
6730 | OPTI_TYPE_RAW_HASH;
6731 dgst_pos0 = 0;
6732 dgst_pos1 = 3;
6733 dgst_pos2 = 2;
6734 dgst_pos3 = 1;
6735 break;
6736
6737 case 50: hash_type = HASH_TYPE_MD5;
6738 salt_type = SALT_TYPE_INTERN;
6739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6740 opts_type = OPTS_TYPE_PT_GENERATE_LE
6741 | OPTS_TYPE_ST_ADD80
6742 | OPTS_TYPE_ST_ADDBITS14;
6743 kern_type = KERN_TYPE_HMACMD5_PW;
6744 dgst_size = DGST_SIZE_4_4;
6745 parse_func = hmacmd5_parse_hash;
6746 sort_by_digest = sort_by_digest_4_4;
6747 opti_type = OPTI_TYPE_ZERO_BYTE
6748 | OPTI_TYPE_NOT_ITERATED;
6749 dgst_pos0 = 0;
6750 dgst_pos1 = 3;
6751 dgst_pos2 = 2;
6752 dgst_pos3 = 1;
6753 break;
6754
6755 case 60: hash_type = HASH_TYPE_MD5;
6756 salt_type = SALT_TYPE_INTERN;
6757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6758 opts_type = OPTS_TYPE_PT_GENERATE_LE
6759 | OPTS_TYPE_PT_ADD80
6760 | OPTS_TYPE_PT_ADDBITS14;
6761 kern_type = KERN_TYPE_HMACMD5_SLT;
6762 dgst_size = DGST_SIZE_4_4;
6763 parse_func = hmacmd5_parse_hash;
6764 sort_by_digest = sort_by_digest_4_4;
6765 opti_type = OPTI_TYPE_ZERO_BYTE
6766 | OPTI_TYPE_NOT_ITERATED;
6767 dgst_pos0 = 0;
6768 dgst_pos1 = 3;
6769 dgst_pos2 = 2;
6770 dgst_pos3 = 1;
6771 break;
6772
6773 case 100: hash_type = HASH_TYPE_SHA1;
6774 salt_type = SALT_TYPE_NONE;
6775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6776 opts_type = OPTS_TYPE_PT_GENERATE_BE
6777 | OPTS_TYPE_PT_ADD80
6778 | OPTS_TYPE_PT_ADDBITS15;
6779 kern_type = KERN_TYPE_SHA1;
6780 dgst_size = DGST_SIZE_4_5;
6781 parse_func = sha1_parse_hash;
6782 sort_by_digest = sort_by_digest_4_5;
6783 opti_type = OPTI_TYPE_ZERO_BYTE
6784 | OPTI_TYPE_PRECOMPUTE_INIT
6785 | OPTI_TYPE_PRECOMPUTE_MERKLE
6786 | OPTI_TYPE_EARLY_SKIP
6787 | OPTI_TYPE_NOT_ITERATED
6788 | OPTI_TYPE_NOT_SALTED
6789 | OPTI_TYPE_RAW_HASH;
6790 dgst_pos0 = 3;
6791 dgst_pos1 = 4;
6792 dgst_pos2 = 2;
6793 dgst_pos3 = 1;
6794 break;
6795
6796 case 101: hash_type = HASH_TYPE_SHA1;
6797 salt_type = SALT_TYPE_NONE;
6798 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6799 opts_type = OPTS_TYPE_PT_GENERATE_BE
6800 | OPTS_TYPE_PT_ADD80
6801 | OPTS_TYPE_PT_ADDBITS15;
6802 kern_type = KERN_TYPE_SHA1;
6803 dgst_size = DGST_SIZE_4_5;
6804 parse_func = sha1b64_parse_hash;
6805 sort_by_digest = sort_by_digest_4_5;
6806 opti_type = OPTI_TYPE_ZERO_BYTE
6807 | OPTI_TYPE_PRECOMPUTE_INIT
6808 | OPTI_TYPE_PRECOMPUTE_MERKLE
6809 | OPTI_TYPE_EARLY_SKIP
6810 | OPTI_TYPE_NOT_ITERATED
6811 | OPTI_TYPE_NOT_SALTED
6812 | OPTI_TYPE_RAW_HASH;
6813 dgst_pos0 = 3;
6814 dgst_pos1 = 4;
6815 dgst_pos2 = 2;
6816 dgst_pos3 = 1;
6817 break;
6818
6819 case 110: hash_type = HASH_TYPE_SHA1;
6820 salt_type = SALT_TYPE_INTERN;
6821 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6822 opts_type = OPTS_TYPE_PT_GENERATE_BE
6823 | OPTS_TYPE_ST_ADD80
6824 | OPTS_TYPE_ST_ADDBITS15;
6825 kern_type = KERN_TYPE_SHA1_PWSLT;
6826 dgst_size = DGST_SIZE_4_5;
6827 parse_func = sha1s_parse_hash;
6828 sort_by_digest = sort_by_digest_4_5;
6829 opti_type = OPTI_TYPE_ZERO_BYTE
6830 | OPTI_TYPE_PRECOMPUTE_INIT
6831 | OPTI_TYPE_PRECOMPUTE_MERKLE
6832 | OPTI_TYPE_EARLY_SKIP
6833 | OPTI_TYPE_NOT_ITERATED
6834 | OPTI_TYPE_APPENDED_SALT
6835 | OPTI_TYPE_RAW_HASH;
6836 dgst_pos0 = 3;
6837 dgst_pos1 = 4;
6838 dgst_pos2 = 2;
6839 dgst_pos3 = 1;
6840 break;
6841
6842 case 111: hash_type = HASH_TYPE_SHA1;
6843 salt_type = SALT_TYPE_EMBEDDED;
6844 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6845 opts_type = OPTS_TYPE_PT_GENERATE_BE
6846 | OPTS_TYPE_ST_ADD80
6847 | OPTS_TYPE_ST_ADDBITS15;
6848 kern_type = KERN_TYPE_SHA1_PWSLT;
6849 dgst_size = DGST_SIZE_4_5;
6850 parse_func = sha1b64s_parse_hash;
6851 sort_by_digest = sort_by_digest_4_5;
6852 opti_type = OPTI_TYPE_ZERO_BYTE
6853 | OPTI_TYPE_PRECOMPUTE_INIT
6854 | OPTI_TYPE_PRECOMPUTE_MERKLE
6855 | OPTI_TYPE_EARLY_SKIP
6856 | OPTI_TYPE_NOT_ITERATED
6857 | OPTI_TYPE_APPENDED_SALT
6858 | OPTI_TYPE_RAW_HASH;
6859 dgst_pos0 = 3;
6860 dgst_pos1 = 4;
6861 dgst_pos2 = 2;
6862 dgst_pos3 = 1;
6863 break;
6864
6865 case 112: hash_type = HASH_TYPE_SHA1;
6866 salt_type = SALT_TYPE_INTERN;
6867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6868 opts_type = OPTS_TYPE_PT_GENERATE_BE
6869 | OPTS_TYPE_ST_ADD80
6870 | OPTS_TYPE_ST_ADDBITS15
6871 | OPTS_TYPE_ST_HEX;
6872 kern_type = KERN_TYPE_SHA1_PWSLT;
6873 dgst_size = DGST_SIZE_4_5;
6874 parse_func = oracles_parse_hash;
6875 sort_by_digest = sort_by_digest_4_5;
6876 opti_type = OPTI_TYPE_ZERO_BYTE
6877 | OPTI_TYPE_PRECOMPUTE_INIT
6878 | OPTI_TYPE_PRECOMPUTE_MERKLE
6879 | OPTI_TYPE_EARLY_SKIP
6880 | OPTI_TYPE_NOT_ITERATED
6881 | OPTI_TYPE_APPENDED_SALT
6882 | OPTI_TYPE_RAW_HASH;
6883 dgst_pos0 = 3;
6884 dgst_pos1 = 4;
6885 dgst_pos2 = 2;
6886 dgst_pos3 = 1;
6887 break;
6888
6889 case 120: hash_type = HASH_TYPE_SHA1;
6890 salt_type = SALT_TYPE_INTERN;
6891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6892 opts_type = OPTS_TYPE_PT_GENERATE_BE
6893 | OPTS_TYPE_PT_ADD80
6894 | OPTS_TYPE_PT_ADDBITS15;
6895 kern_type = KERN_TYPE_SHA1_SLTPW;
6896 dgst_size = DGST_SIZE_4_5;
6897 parse_func = sha1s_parse_hash;
6898 sort_by_digest = sort_by_digest_4_5;
6899 opti_type = OPTI_TYPE_ZERO_BYTE
6900 | OPTI_TYPE_PRECOMPUTE_INIT
6901 | OPTI_TYPE_PRECOMPUTE_MERKLE
6902 | OPTI_TYPE_EARLY_SKIP
6903 | OPTI_TYPE_NOT_ITERATED
6904 | OPTI_TYPE_PREPENDED_SALT
6905 | OPTI_TYPE_RAW_HASH;
6906 dgst_pos0 = 3;
6907 dgst_pos1 = 4;
6908 dgst_pos2 = 2;
6909 dgst_pos3 = 1;
6910 break;
6911
6912 case 121: hash_type = HASH_TYPE_SHA1;
6913 salt_type = SALT_TYPE_INTERN;
6914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6915 opts_type = OPTS_TYPE_PT_GENERATE_BE
6916 | OPTS_TYPE_PT_ADD80
6917 | OPTS_TYPE_PT_ADDBITS15
6918 | OPTS_TYPE_ST_LOWER;
6919 kern_type = KERN_TYPE_SHA1_SLTPW;
6920 dgst_size = DGST_SIZE_4_5;
6921 parse_func = smf_parse_hash;
6922 sort_by_digest = sort_by_digest_4_5;
6923 opti_type = OPTI_TYPE_ZERO_BYTE
6924 | OPTI_TYPE_PRECOMPUTE_INIT
6925 | OPTI_TYPE_PRECOMPUTE_MERKLE
6926 | OPTI_TYPE_EARLY_SKIP
6927 | OPTI_TYPE_NOT_ITERATED
6928 | OPTI_TYPE_PREPENDED_SALT
6929 | OPTI_TYPE_RAW_HASH;
6930 dgst_pos0 = 3;
6931 dgst_pos1 = 4;
6932 dgst_pos2 = 2;
6933 dgst_pos3 = 1;
6934 break;
6935
6936 case 122: hash_type = HASH_TYPE_SHA1;
6937 salt_type = SALT_TYPE_EMBEDDED;
6938 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6939 opts_type = OPTS_TYPE_PT_GENERATE_BE
6940 | OPTS_TYPE_PT_ADD80
6941 | OPTS_TYPE_PT_ADDBITS15
6942 | OPTS_TYPE_ST_HEX;
6943 kern_type = KERN_TYPE_SHA1_SLTPW;
6944 dgst_size = DGST_SIZE_4_5;
6945 parse_func = osx1_parse_hash;
6946 sort_by_digest = sort_by_digest_4_5;
6947 opti_type = OPTI_TYPE_ZERO_BYTE
6948 | OPTI_TYPE_PRECOMPUTE_INIT
6949 | OPTI_TYPE_PRECOMPUTE_MERKLE
6950 | OPTI_TYPE_EARLY_SKIP
6951 | OPTI_TYPE_NOT_ITERATED
6952 | OPTI_TYPE_PREPENDED_SALT
6953 | OPTI_TYPE_RAW_HASH;
6954 dgst_pos0 = 3;
6955 dgst_pos1 = 4;
6956 dgst_pos2 = 2;
6957 dgst_pos3 = 1;
6958 break;
6959
6960 case 124: hash_type = HASH_TYPE_SHA1;
6961 salt_type = SALT_TYPE_EMBEDDED;
6962 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6963 opts_type = OPTS_TYPE_PT_GENERATE_BE
6964 | OPTS_TYPE_PT_ADD80
6965 | OPTS_TYPE_PT_ADDBITS15;
6966 kern_type = KERN_TYPE_SHA1_SLTPW;
6967 dgst_size = DGST_SIZE_4_5;
6968 parse_func = djangosha1_parse_hash;
6969 sort_by_digest = sort_by_digest_4_5;
6970 opti_type = OPTI_TYPE_ZERO_BYTE
6971 | OPTI_TYPE_PRECOMPUTE_INIT
6972 | OPTI_TYPE_PRECOMPUTE_MERKLE
6973 | OPTI_TYPE_EARLY_SKIP
6974 | OPTI_TYPE_NOT_ITERATED
6975 | OPTI_TYPE_PREPENDED_SALT
6976 | OPTI_TYPE_RAW_HASH;
6977 dgst_pos0 = 3;
6978 dgst_pos1 = 4;
6979 dgst_pos2 = 2;
6980 dgst_pos3 = 1;
6981 break;
6982
6983 case 130: hash_type = HASH_TYPE_SHA1;
6984 salt_type = SALT_TYPE_INTERN;
6985 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6986 opts_type = OPTS_TYPE_PT_GENERATE_BE
6987 | OPTS_TYPE_PT_UNICODE
6988 | OPTS_TYPE_ST_ADD80
6989 | OPTS_TYPE_ST_ADDBITS15;
6990 kern_type = KERN_TYPE_SHA1_PWUSLT;
6991 dgst_size = DGST_SIZE_4_5;
6992 parse_func = sha1s_parse_hash;
6993 sort_by_digest = sort_by_digest_4_5;
6994 opti_type = OPTI_TYPE_ZERO_BYTE
6995 | OPTI_TYPE_PRECOMPUTE_INIT
6996 | OPTI_TYPE_PRECOMPUTE_MERKLE
6997 | OPTI_TYPE_EARLY_SKIP
6998 | OPTI_TYPE_NOT_ITERATED
6999 | OPTI_TYPE_APPENDED_SALT
7000 | OPTI_TYPE_RAW_HASH;
7001 dgst_pos0 = 3;
7002 dgst_pos1 = 4;
7003 dgst_pos2 = 2;
7004 dgst_pos3 = 1;
7005 break;
7006
7007 case 131: hash_type = HASH_TYPE_SHA1;
7008 salt_type = SALT_TYPE_EMBEDDED;
7009 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7010 opts_type = OPTS_TYPE_PT_GENERATE_BE
7011 | OPTS_TYPE_PT_UNICODE
7012 | OPTS_TYPE_PT_UPPER
7013 | OPTS_TYPE_ST_ADD80
7014 | OPTS_TYPE_ST_ADDBITS15
7015 | OPTS_TYPE_ST_HEX;
7016 kern_type = KERN_TYPE_SHA1_PWUSLT;
7017 dgst_size = DGST_SIZE_4_5;
7018 parse_func = mssql2000_parse_hash;
7019 sort_by_digest = sort_by_digest_4_5;
7020 opti_type = OPTI_TYPE_ZERO_BYTE
7021 | OPTI_TYPE_PRECOMPUTE_INIT
7022 | OPTI_TYPE_PRECOMPUTE_MERKLE
7023 | OPTI_TYPE_EARLY_SKIP
7024 | OPTI_TYPE_NOT_ITERATED
7025 | OPTI_TYPE_APPENDED_SALT
7026 | OPTI_TYPE_RAW_HASH;
7027 dgst_pos0 = 3;
7028 dgst_pos1 = 4;
7029 dgst_pos2 = 2;
7030 dgst_pos3 = 1;
7031 break;
7032
7033 case 132: hash_type = HASH_TYPE_SHA1;
7034 salt_type = SALT_TYPE_EMBEDDED;
7035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7036 opts_type = OPTS_TYPE_PT_GENERATE_BE
7037 | OPTS_TYPE_PT_UNICODE
7038 | OPTS_TYPE_ST_ADD80
7039 | OPTS_TYPE_ST_ADDBITS15
7040 | OPTS_TYPE_ST_HEX;
7041 kern_type = KERN_TYPE_SHA1_PWUSLT;
7042 dgst_size = DGST_SIZE_4_5;
7043 parse_func = mssql2005_parse_hash;
7044 sort_by_digest = sort_by_digest_4_5;
7045 opti_type = OPTI_TYPE_ZERO_BYTE
7046 | OPTI_TYPE_PRECOMPUTE_INIT
7047 | OPTI_TYPE_PRECOMPUTE_MERKLE
7048 | OPTI_TYPE_EARLY_SKIP
7049 | OPTI_TYPE_NOT_ITERATED
7050 | OPTI_TYPE_APPENDED_SALT
7051 | OPTI_TYPE_RAW_HASH;
7052 dgst_pos0 = 3;
7053 dgst_pos1 = 4;
7054 dgst_pos2 = 2;
7055 dgst_pos3 = 1;
7056 break;
7057
7058 case 133: hash_type = HASH_TYPE_SHA1;
7059 salt_type = SALT_TYPE_EMBEDDED;
7060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7061 opts_type = OPTS_TYPE_PT_GENERATE_BE
7062 | OPTS_TYPE_PT_UNICODE
7063 | OPTS_TYPE_ST_ADD80
7064 | OPTS_TYPE_ST_ADDBITS15;
7065 kern_type = KERN_TYPE_SHA1_PWUSLT;
7066 dgst_size = DGST_SIZE_4_5;
7067 parse_func = peoplesoft_parse_hash;
7068 sort_by_digest = sort_by_digest_4_5;
7069 opti_type = OPTI_TYPE_ZERO_BYTE
7070 | OPTI_TYPE_PRECOMPUTE_INIT
7071 | OPTI_TYPE_PRECOMPUTE_MERKLE
7072 | OPTI_TYPE_EARLY_SKIP
7073 | OPTI_TYPE_NOT_ITERATED
7074 | OPTI_TYPE_APPENDED_SALT
7075 | OPTI_TYPE_RAW_HASH;
7076 dgst_pos0 = 3;
7077 dgst_pos1 = 4;
7078 dgst_pos2 = 2;
7079 dgst_pos3 = 1;
7080 break;
7081
7082 case 140: hash_type = HASH_TYPE_SHA1;
7083 salt_type = SALT_TYPE_INTERN;
7084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7085 opts_type = OPTS_TYPE_PT_GENERATE_BE
7086 | OPTS_TYPE_PT_ADD80
7087 | OPTS_TYPE_PT_ADDBITS15
7088 | OPTS_TYPE_PT_UNICODE;
7089 kern_type = KERN_TYPE_SHA1_SLTPWU;
7090 dgst_size = DGST_SIZE_4_5;
7091 parse_func = sha1s_parse_hash;
7092 sort_by_digest = sort_by_digest_4_5;
7093 opti_type = OPTI_TYPE_ZERO_BYTE
7094 | OPTI_TYPE_PRECOMPUTE_INIT
7095 | OPTI_TYPE_PRECOMPUTE_MERKLE
7096 | OPTI_TYPE_EARLY_SKIP
7097 | OPTI_TYPE_NOT_ITERATED
7098 | OPTI_TYPE_PREPENDED_SALT
7099 | OPTI_TYPE_RAW_HASH;
7100 dgst_pos0 = 3;
7101 dgst_pos1 = 4;
7102 dgst_pos2 = 2;
7103 dgst_pos3 = 1;
7104 break;
7105
7106 case 141: hash_type = HASH_TYPE_SHA1;
7107 salt_type = SALT_TYPE_EMBEDDED;
7108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7109 opts_type = OPTS_TYPE_PT_GENERATE_BE
7110 | OPTS_TYPE_PT_ADD80
7111 | OPTS_TYPE_PT_ADDBITS15
7112 | OPTS_TYPE_PT_UNICODE
7113 | OPTS_TYPE_ST_BASE64;
7114 kern_type = KERN_TYPE_SHA1_SLTPWU;
7115 dgst_size = DGST_SIZE_4_5;
7116 parse_func = episerver_parse_hash;
7117 sort_by_digest = sort_by_digest_4_5;
7118 opti_type = OPTI_TYPE_ZERO_BYTE
7119 | OPTI_TYPE_PRECOMPUTE_INIT
7120 | OPTI_TYPE_PRECOMPUTE_MERKLE
7121 | OPTI_TYPE_EARLY_SKIP
7122 | OPTI_TYPE_NOT_ITERATED
7123 | OPTI_TYPE_PREPENDED_SALT
7124 | OPTI_TYPE_RAW_HASH;
7125 dgst_pos0 = 3;
7126 dgst_pos1 = 4;
7127 dgst_pos2 = 2;
7128 dgst_pos3 = 1;
7129 break;
7130
7131 case 150: hash_type = HASH_TYPE_SHA1;
7132 salt_type = SALT_TYPE_INTERN;
7133 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7134 opts_type = OPTS_TYPE_PT_GENERATE_BE
7135 | OPTS_TYPE_ST_ADD80
7136 | OPTS_TYPE_ST_ADDBITS15;
7137 kern_type = KERN_TYPE_HMACSHA1_PW;
7138 dgst_size = DGST_SIZE_4_5;
7139 parse_func = hmacsha1_parse_hash;
7140 sort_by_digest = sort_by_digest_4_5;
7141 opti_type = OPTI_TYPE_ZERO_BYTE
7142 | OPTI_TYPE_NOT_ITERATED;
7143 dgst_pos0 = 3;
7144 dgst_pos1 = 4;
7145 dgst_pos2 = 2;
7146 dgst_pos3 = 1;
7147 break;
7148
7149 case 160: hash_type = HASH_TYPE_SHA1;
7150 salt_type = SALT_TYPE_INTERN;
7151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7152 opts_type = OPTS_TYPE_PT_GENERATE_BE
7153 | OPTS_TYPE_PT_ADD80
7154 | OPTS_TYPE_PT_ADDBITS15;
7155 kern_type = KERN_TYPE_HMACSHA1_SLT;
7156 dgst_size = DGST_SIZE_4_5;
7157 parse_func = hmacsha1_parse_hash;
7158 sort_by_digest = sort_by_digest_4_5;
7159 opti_type = OPTI_TYPE_ZERO_BYTE
7160 | OPTI_TYPE_NOT_ITERATED;
7161 dgst_pos0 = 3;
7162 dgst_pos1 = 4;
7163 dgst_pos2 = 2;
7164 dgst_pos3 = 1;
7165 break;
7166
7167 case 190: hash_type = HASH_TYPE_SHA1;
7168 salt_type = SALT_TYPE_NONE;
7169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7170 opts_type = OPTS_TYPE_PT_GENERATE_BE
7171 | OPTS_TYPE_PT_ADD80
7172 | OPTS_TYPE_PT_ADDBITS15;
7173 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7174 dgst_size = DGST_SIZE_4_5;
7175 parse_func = sha1linkedin_parse_hash;
7176 sort_by_digest = sort_by_digest_4_5;
7177 opti_type = OPTI_TYPE_ZERO_BYTE
7178 | OPTI_TYPE_PRECOMPUTE_INIT
7179 | OPTI_TYPE_EARLY_SKIP
7180 | OPTI_TYPE_NOT_ITERATED
7181 | OPTI_TYPE_NOT_SALTED;
7182 dgst_pos0 = 0;
7183 dgst_pos1 = 4;
7184 dgst_pos2 = 3;
7185 dgst_pos3 = 2;
7186 break;
7187
7188 case 200: hash_type = HASH_TYPE_MYSQL;
7189 salt_type = SALT_TYPE_NONE;
7190 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7191 opts_type = 0;
7192 kern_type = KERN_TYPE_MYSQL;
7193 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7194 parse_func = mysql323_parse_hash;
7195 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7196 opti_type = OPTI_TYPE_ZERO_BYTE;
7197 dgst_pos0 = 0;
7198 dgst_pos1 = 1;
7199 dgst_pos2 = 2;
7200 dgst_pos3 = 3;
7201 break;
7202
7203 case 300: hash_type = HASH_TYPE_SHA1;
7204 salt_type = SALT_TYPE_NONE;
7205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7206 opts_type = OPTS_TYPE_PT_GENERATE_BE
7207 | OPTS_TYPE_PT_ADD80
7208 | OPTS_TYPE_PT_ADDBITS15;
7209 kern_type = KERN_TYPE_MYSQL41;
7210 dgst_size = DGST_SIZE_4_5;
7211 parse_func = sha1_parse_hash;
7212 sort_by_digest = sort_by_digest_4_5;
7213 opti_type = OPTI_TYPE_ZERO_BYTE
7214 | OPTI_TYPE_PRECOMPUTE_INIT
7215 | OPTI_TYPE_PRECOMPUTE_MERKLE
7216 | OPTI_TYPE_EARLY_SKIP
7217 | OPTI_TYPE_NOT_ITERATED
7218 | OPTI_TYPE_NOT_SALTED;
7219 dgst_pos0 = 3;
7220 dgst_pos1 = 4;
7221 dgst_pos2 = 2;
7222 dgst_pos3 = 1;
7223 break;
7224
7225 case 400: hash_type = HASH_TYPE_MD5;
7226 salt_type = SALT_TYPE_EMBEDDED;
7227 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7228 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7229 kern_type = KERN_TYPE_PHPASS;
7230 dgst_size = DGST_SIZE_4_4;
7231 parse_func = phpass_parse_hash;
7232 sort_by_digest = sort_by_digest_4_4;
7233 opti_type = OPTI_TYPE_ZERO_BYTE;
7234 dgst_pos0 = 0;
7235 dgst_pos1 = 1;
7236 dgst_pos2 = 2;
7237 dgst_pos3 = 3;
7238 break;
7239
7240 case 500: hash_type = HASH_TYPE_MD5;
7241 salt_type = SALT_TYPE_EMBEDDED;
7242 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7243 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7244 kern_type = KERN_TYPE_MD5CRYPT;
7245 dgst_size = DGST_SIZE_4_4;
7246 parse_func = md5crypt_parse_hash;
7247 sort_by_digest = sort_by_digest_4_4;
7248 opti_type = OPTI_TYPE_ZERO_BYTE;
7249 dgst_pos0 = 0;
7250 dgst_pos1 = 1;
7251 dgst_pos2 = 2;
7252 dgst_pos3 = 3;
7253 break;
7254
7255 case 501: hash_type = HASH_TYPE_MD5;
7256 salt_type = SALT_TYPE_EMBEDDED;
7257 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7258 opts_type = OPTS_TYPE_PT_GENERATE_LE
7259 | OPTS_TYPE_HASH_COPY;
7260 kern_type = KERN_TYPE_MD5CRYPT;
7261 dgst_size = DGST_SIZE_4_4;
7262 parse_func = juniper_parse_hash;
7263 sort_by_digest = sort_by_digest_4_4;
7264 opti_type = OPTI_TYPE_ZERO_BYTE;
7265 dgst_pos0 = 0;
7266 dgst_pos1 = 1;
7267 dgst_pos2 = 2;
7268 dgst_pos3 = 3;
7269 break;
7270
7271 case 900: hash_type = HASH_TYPE_MD4;
7272 salt_type = SALT_TYPE_NONE;
7273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7274 opts_type = OPTS_TYPE_PT_GENERATE_LE
7275 | OPTS_TYPE_PT_ADD80
7276 | OPTS_TYPE_PT_ADDBITS14;
7277 kern_type = KERN_TYPE_MD4;
7278 dgst_size = DGST_SIZE_4_4;
7279 parse_func = md4_parse_hash;
7280 sort_by_digest = sort_by_digest_4_4;
7281 opti_type = OPTI_TYPE_ZERO_BYTE
7282 | OPTI_TYPE_PRECOMPUTE_INIT
7283 | OPTI_TYPE_PRECOMPUTE_MERKLE
7284 | OPTI_TYPE_MEET_IN_MIDDLE
7285 | OPTI_TYPE_EARLY_SKIP
7286 | OPTI_TYPE_NOT_ITERATED
7287 | OPTI_TYPE_NOT_SALTED
7288 | OPTI_TYPE_RAW_HASH;
7289 dgst_pos0 = 0;
7290 dgst_pos1 = 3;
7291 dgst_pos2 = 2;
7292 dgst_pos3 = 1;
7293 break;
7294
7295 case 1000: hash_type = HASH_TYPE_MD4;
7296 salt_type = SALT_TYPE_NONE;
7297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7298 opts_type = OPTS_TYPE_PT_GENERATE_LE
7299 | OPTS_TYPE_PT_ADD80
7300 | OPTS_TYPE_PT_ADDBITS14
7301 | OPTS_TYPE_PT_UNICODE;
7302 kern_type = KERN_TYPE_MD4_PWU;
7303 dgst_size = DGST_SIZE_4_4;
7304 parse_func = md4_parse_hash;
7305 sort_by_digest = sort_by_digest_4_4;
7306 opti_type = OPTI_TYPE_ZERO_BYTE
7307 | OPTI_TYPE_PRECOMPUTE_INIT
7308 | OPTI_TYPE_PRECOMPUTE_MERKLE
7309 | OPTI_TYPE_MEET_IN_MIDDLE
7310 | OPTI_TYPE_EARLY_SKIP
7311 | OPTI_TYPE_NOT_ITERATED
7312 | OPTI_TYPE_NOT_SALTED
7313 | OPTI_TYPE_RAW_HASH;
7314 dgst_pos0 = 0;
7315 dgst_pos1 = 3;
7316 dgst_pos2 = 2;
7317 dgst_pos3 = 1;
7318 break;
7319
7320 case 1100: hash_type = HASH_TYPE_MD4;
7321 salt_type = SALT_TYPE_INTERN;
7322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7323 opts_type = OPTS_TYPE_PT_GENERATE_LE
7324 | OPTS_TYPE_PT_ADD80
7325 | OPTS_TYPE_PT_ADDBITS14
7326 | OPTS_TYPE_PT_UNICODE
7327 | OPTS_TYPE_ST_ADD80
7328 | OPTS_TYPE_ST_UNICODE
7329 | OPTS_TYPE_ST_LOWER;
7330 kern_type = KERN_TYPE_MD44_PWUSLT;
7331 dgst_size = DGST_SIZE_4_4;
7332 parse_func = dcc_parse_hash;
7333 sort_by_digest = sort_by_digest_4_4;
7334 opti_type = OPTI_TYPE_ZERO_BYTE
7335 | OPTI_TYPE_PRECOMPUTE_INIT
7336 | OPTI_TYPE_PRECOMPUTE_MERKLE
7337 | OPTI_TYPE_EARLY_SKIP
7338 | OPTI_TYPE_NOT_ITERATED;
7339 dgst_pos0 = 0;
7340 dgst_pos1 = 3;
7341 dgst_pos2 = 2;
7342 dgst_pos3 = 1;
7343 break;
7344
7345 case 1400: hash_type = HASH_TYPE_SHA256;
7346 salt_type = SALT_TYPE_NONE;
7347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7348 opts_type = OPTS_TYPE_PT_GENERATE_BE
7349 | OPTS_TYPE_PT_ADD80
7350 | OPTS_TYPE_PT_ADDBITS15;
7351 kern_type = KERN_TYPE_SHA256;
7352 dgst_size = DGST_SIZE_4_8;
7353 parse_func = sha256_parse_hash;
7354 sort_by_digest = sort_by_digest_4_8;
7355 opti_type = OPTI_TYPE_ZERO_BYTE
7356 | OPTI_TYPE_PRECOMPUTE_INIT
7357 | OPTI_TYPE_PRECOMPUTE_MERKLE
7358 | OPTI_TYPE_EARLY_SKIP
7359 | OPTI_TYPE_NOT_ITERATED
7360 | OPTI_TYPE_NOT_SALTED
7361 | OPTI_TYPE_RAW_HASH;
7362 dgst_pos0 = 3;
7363 dgst_pos1 = 7;
7364 dgst_pos2 = 2;
7365 dgst_pos3 = 6;
7366 break;
7367
7368 case 1410: hash_type = HASH_TYPE_SHA256;
7369 salt_type = SALT_TYPE_INTERN;
7370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7371 opts_type = OPTS_TYPE_PT_GENERATE_BE
7372 | OPTS_TYPE_ST_ADD80
7373 | OPTS_TYPE_ST_ADDBITS15;
7374 kern_type = KERN_TYPE_SHA256_PWSLT;
7375 dgst_size = DGST_SIZE_4_8;
7376 parse_func = sha256s_parse_hash;
7377 sort_by_digest = sort_by_digest_4_8;
7378 opti_type = OPTI_TYPE_ZERO_BYTE
7379 | OPTI_TYPE_PRECOMPUTE_INIT
7380 | OPTI_TYPE_PRECOMPUTE_MERKLE
7381 | OPTI_TYPE_EARLY_SKIP
7382 | OPTI_TYPE_NOT_ITERATED
7383 | OPTI_TYPE_APPENDED_SALT
7384 | OPTI_TYPE_RAW_HASH;
7385 dgst_pos0 = 3;
7386 dgst_pos1 = 7;
7387 dgst_pos2 = 2;
7388 dgst_pos3 = 6;
7389 break;
7390
7391 case 1420: hash_type = HASH_TYPE_SHA256;
7392 salt_type = SALT_TYPE_INTERN;
7393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7394 opts_type = OPTS_TYPE_PT_GENERATE_BE
7395 | OPTS_TYPE_PT_ADD80
7396 | OPTS_TYPE_PT_ADDBITS15;
7397 kern_type = KERN_TYPE_SHA256_SLTPW;
7398 dgst_size = DGST_SIZE_4_8;
7399 parse_func = sha256s_parse_hash;
7400 sort_by_digest = sort_by_digest_4_8;
7401 opti_type = OPTI_TYPE_ZERO_BYTE
7402 | OPTI_TYPE_PRECOMPUTE_INIT
7403 | OPTI_TYPE_PRECOMPUTE_MERKLE
7404 | OPTI_TYPE_EARLY_SKIP
7405 | OPTI_TYPE_NOT_ITERATED
7406 | OPTI_TYPE_PREPENDED_SALT
7407 | OPTI_TYPE_RAW_HASH;
7408 dgst_pos0 = 3;
7409 dgst_pos1 = 7;
7410 dgst_pos2 = 2;
7411 dgst_pos3 = 6;
7412 break;
7413
7414 case 1421: hash_type = HASH_TYPE_SHA256;
7415 salt_type = SALT_TYPE_EMBEDDED;
7416 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7417 opts_type = OPTS_TYPE_PT_GENERATE_BE
7418 | OPTS_TYPE_PT_ADD80
7419 | OPTS_TYPE_PT_ADDBITS15;
7420 kern_type = KERN_TYPE_SHA256_SLTPW;
7421 dgst_size = DGST_SIZE_4_8;
7422 parse_func = hmailserver_parse_hash;
7423 sort_by_digest = sort_by_digest_4_8;
7424 opti_type = OPTI_TYPE_ZERO_BYTE
7425 | OPTI_TYPE_PRECOMPUTE_INIT
7426 | OPTI_TYPE_PRECOMPUTE_MERKLE
7427 | OPTI_TYPE_EARLY_SKIP
7428 | OPTI_TYPE_NOT_ITERATED
7429 | OPTI_TYPE_PREPENDED_SALT
7430 | OPTI_TYPE_RAW_HASH;
7431 dgst_pos0 = 3;
7432 dgst_pos1 = 7;
7433 dgst_pos2 = 2;
7434 dgst_pos3 = 6;
7435 break;
7436
7437 case 1430: hash_type = HASH_TYPE_SHA256;
7438 salt_type = SALT_TYPE_INTERN;
7439 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7440 opts_type = OPTS_TYPE_PT_GENERATE_BE
7441 | OPTS_TYPE_PT_UNICODE
7442 | OPTS_TYPE_ST_ADD80
7443 | OPTS_TYPE_ST_ADDBITS15;
7444 kern_type = KERN_TYPE_SHA256_PWUSLT;
7445 dgst_size = DGST_SIZE_4_8;
7446 parse_func = sha256s_parse_hash;
7447 sort_by_digest = sort_by_digest_4_8;
7448 opti_type = OPTI_TYPE_ZERO_BYTE
7449 | OPTI_TYPE_PRECOMPUTE_INIT
7450 | OPTI_TYPE_PRECOMPUTE_MERKLE
7451 | OPTI_TYPE_EARLY_SKIP
7452 | OPTI_TYPE_NOT_ITERATED
7453 | OPTI_TYPE_APPENDED_SALT
7454 | OPTI_TYPE_RAW_HASH;
7455 dgst_pos0 = 3;
7456 dgst_pos1 = 7;
7457 dgst_pos2 = 2;
7458 dgst_pos3 = 6;
7459 break;
7460
7461 case 1440: hash_type = HASH_TYPE_SHA256;
7462 salt_type = SALT_TYPE_INTERN;
7463 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7464 opts_type = OPTS_TYPE_PT_GENERATE_BE
7465 | OPTS_TYPE_PT_ADD80
7466 | OPTS_TYPE_PT_ADDBITS15
7467 | OPTS_TYPE_PT_UNICODE;
7468 kern_type = KERN_TYPE_SHA256_SLTPWU;
7469 dgst_size = DGST_SIZE_4_8;
7470 parse_func = sha256s_parse_hash;
7471 sort_by_digest = sort_by_digest_4_8;
7472 opti_type = OPTI_TYPE_ZERO_BYTE
7473 | OPTI_TYPE_PRECOMPUTE_INIT
7474 | OPTI_TYPE_PRECOMPUTE_MERKLE
7475 | OPTI_TYPE_EARLY_SKIP
7476 | OPTI_TYPE_NOT_ITERATED
7477 | OPTI_TYPE_PREPENDED_SALT
7478 | OPTI_TYPE_RAW_HASH;
7479 dgst_pos0 = 3;
7480 dgst_pos1 = 7;
7481 dgst_pos2 = 2;
7482 dgst_pos3 = 6;
7483 break;
7484
7485 case 1441: hash_type = HASH_TYPE_SHA256;
7486 salt_type = SALT_TYPE_EMBEDDED;
7487 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7488 opts_type = OPTS_TYPE_PT_GENERATE_BE
7489 | OPTS_TYPE_PT_ADD80
7490 | OPTS_TYPE_PT_ADDBITS15
7491 | OPTS_TYPE_PT_UNICODE
7492 | OPTS_TYPE_ST_BASE64;
7493 kern_type = KERN_TYPE_SHA256_SLTPWU;
7494 dgst_size = DGST_SIZE_4_8;
7495 parse_func = episerver4_parse_hash;
7496 sort_by_digest = sort_by_digest_4_8;
7497 opti_type = OPTI_TYPE_ZERO_BYTE
7498 | OPTI_TYPE_PRECOMPUTE_INIT
7499 | OPTI_TYPE_PRECOMPUTE_MERKLE
7500 | OPTI_TYPE_EARLY_SKIP
7501 | OPTI_TYPE_NOT_ITERATED
7502 | OPTI_TYPE_PREPENDED_SALT
7503 | OPTI_TYPE_RAW_HASH;
7504 dgst_pos0 = 3;
7505 dgst_pos1 = 7;
7506 dgst_pos2 = 2;
7507 dgst_pos3 = 6;
7508 break;
7509
7510 case 1450: hash_type = HASH_TYPE_SHA256;
7511 salt_type = SALT_TYPE_INTERN;
7512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7513 opts_type = OPTS_TYPE_PT_GENERATE_BE
7514 | OPTS_TYPE_ST_ADD80;
7515 kern_type = KERN_TYPE_HMACSHA256_PW;
7516 dgst_size = DGST_SIZE_4_8;
7517 parse_func = hmacsha256_parse_hash;
7518 sort_by_digest = sort_by_digest_4_8;
7519 opti_type = OPTI_TYPE_ZERO_BYTE
7520 | OPTI_TYPE_NOT_ITERATED;
7521 dgst_pos0 = 3;
7522 dgst_pos1 = 7;
7523 dgst_pos2 = 2;
7524 dgst_pos3 = 6;
7525 break;
7526
7527 case 1460: hash_type = HASH_TYPE_SHA256;
7528 salt_type = SALT_TYPE_INTERN;
7529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7530 opts_type = OPTS_TYPE_PT_GENERATE_BE
7531 | OPTS_TYPE_PT_ADD80
7532 | OPTS_TYPE_PT_ADDBITS15;
7533 kern_type = KERN_TYPE_HMACSHA256_SLT;
7534 dgst_size = DGST_SIZE_4_8;
7535 parse_func = hmacsha256_parse_hash;
7536 sort_by_digest = sort_by_digest_4_8;
7537 opti_type = OPTI_TYPE_ZERO_BYTE
7538 | OPTI_TYPE_NOT_ITERATED;
7539 dgst_pos0 = 3;
7540 dgst_pos1 = 7;
7541 dgst_pos2 = 2;
7542 dgst_pos3 = 6;
7543 break;
7544
7545 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7546 salt_type = SALT_TYPE_EMBEDDED;
7547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7548 opts_type = OPTS_TYPE_PT_GENERATE_LE
7549 | OPTS_TYPE_PT_BITSLICE;
7550 kern_type = KERN_TYPE_DESCRYPT;
7551 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7552 parse_func = descrypt_parse_hash;
7553 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7554 opti_type = OPTI_TYPE_ZERO_BYTE
7555 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7556 dgst_pos0 = 0;
7557 dgst_pos1 = 1;
7558 dgst_pos2 = 2;
7559 dgst_pos3 = 3;
7560 break;
7561
7562 case 1600: hash_type = HASH_TYPE_MD5;
7563 salt_type = SALT_TYPE_EMBEDDED;
7564 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7565 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7566 kern_type = KERN_TYPE_APR1CRYPT;
7567 dgst_size = DGST_SIZE_4_4;
7568 parse_func = md5apr1_parse_hash;
7569 sort_by_digest = sort_by_digest_4_4;
7570 opti_type = OPTI_TYPE_ZERO_BYTE;
7571 dgst_pos0 = 0;
7572 dgst_pos1 = 1;
7573 dgst_pos2 = 2;
7574 dgst_pos3 = 3;
7575 break;
7576
7577 case 1700: hash_type = HASH_TYPE_SHA512;
7578 salt_type = SALT_TYPE_NONE;
7579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7580 opts_type = OPTS_TYPE_PT_GENERATE_BE
7581 | OPTS_TYPE_PT_ADD80
7582 | OPTS_TYPE_PT_ADDBITS15;
7583 kern_type = KERN_TYPE_SHA512;
7584 dgst_size = DGST_SIZE_8_8;
7585 parse_func = sha512_parse_hash;
7586 sort_by_digest = sort_by_digest_8_8;
7587 opti_type = OPTI_TYPE_ZERO_BYTE
7588 | OPTI_TYPE_PRECOMPUTE_INIT
7589 | OPTI_TYPE_PRECOMPUTE_MERKLE
7590 | OPTI_TYPE_EARLY_SKIP
7591 | OPTI_TYPE_NOT_ITERATED
7592 | OPTI_TYPE_NOT_SALTED
7593 | OPTI_TYPE_RAW_HASH;
7594 dgst_pos0 = 14;
7595 dgst_pos1 = 15;
7596 dgst_pos2 = 6;
7597 dgst_pos3 = 7;
7598 break;
7599
7600 case 1710: hash_type = HASH_TYPE_SHA512;
7601 salt_type = SALT_TYPE_INTERN;
7602 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7603 opts_type = OPTS_TYPE_PT_GENERATE_BE
7604 | OPTS_TYPE_ST_ADD80
7605 | OPTS_TYPE_ST_ADDBITS15;
7606 kern_type = KERN_TYPE_SHA512_PWSLT;
7607 dgst_size = DGST_SIZE_8_8;
7608 parse_func = sha512s_parse_hash;
7609 sort_by_digest = sort_by_digest_8_8;
7610 opti_type = OPTI_TYPE_ZERO_BYTE
7611 | OPTI_TYPE_PRECOMPUTE_INIT
7612 | OPTI_TYPE_PRECOMPUTE_MERKLE
7613 | OPTI_TYPE_EARLY_SKIP
7614 | OPTI_TYPE_NOT_ITERATED
7615 | OPTI_TYPE_APPENDED_SALT
7616 | OPTI_TYPE_RAW_HASH;
7617 dgst_pos0 = 14;
7618 dgst_pos1 = 15;
7619 dgst_pos2 = 6;
7620 dgst_pos3 = 7;
7621 break;
7622
7623 case 1711: hash_type = HASH_TYPE_SHA512;
7624 salt_type = SALT_TYPE_EMBEDDED;
7625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7626 opts_type = OPTS_TYPE_PT_GENERATE_BE
7627 | OPTS_TYPE_ST_ADD80
7628 | OPTS_TYPE_ST_ADDBITS15;
7629 kern_type = KERN_TYPE_SHA512_PWSLT;
7630 dgst_size = DGST_SIZE_8_8;
7631 parse_func = sha512b64s_parse_hash;
7632 sort_by_digest = sort_by_digest_8_8;
7633 opti_type = OPTI_TYPE_ZERO_BYTE
7634 | OPTI_TYPE_PRECOMPUTE_INIT
7635 | OPTI_TYPE_PRECOMPUTE_MERKLE
7636 | OPTI_TYPE_EARLY_SKIP
7637 | OPTI_TYPE_NOT_ITERATED
7638 | OPTI_TYPE_APPENDED_SALT
7639 | OPTI_TYPE_RAW_HASH;
7640 dgst_pos0 = 14;
7641 dgst_pos1 = 15;
7642 dgst_pos2 = 6;
7643 dgst_pos3 = 7;
7644 break;
7645
7646 case 1720: hash_type = HASH_TYPE_SHA512;
7647 salt_type = SALT_TYPE_INTERN;
7648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7649 opts_type = OPTS_TYPE_PT_GENERATE_BE
7650 | OPTS_TYPE_PT_ADD80
7651 | OPTS_TYPE_PT_ADDBITS15;
7652 kern_type = KERN_TYPE_SHA512_SLTPW;
7653 dgst_size = DGST_SIZE_8_8;
7654 parse_func = sha512s_parse_hash;
7655 sort_by_digest = sort_by_digest_8_8;
7656 opti_type = OPTI_TYPE_ZERO_BYTE
7657 | OPTI_TYPE_PRECOMPUTE_INIT
7658 | OPTI_TYPE_PRECOMPUTE_MERKLE
7659 | OPTI_TYPE_EARLY_SKIP
7660 | OPTI_TYPE_NOT_ITERATED
7661 | OPTI_TYPE_PREPENDED_SALT
7662 | OPTI_TYPE_RAW_HASH;
7663 dgst_pos0 = 14;
7664 dgst_pos1 = 15;
7665 dgst_pos2 = 6;
7666 dgst_pos3 = 7;
7667 break;
7668
7669 case 1722: hash_type = HASH_TYPE_SHA512;
7670 salt_type = SALT_TYPE_EMBEDDED;
7671 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7672 opts_type = OPTS_TYPE_PT_GENERATE_BE
7673 | OPTS_TYPE_PT_ADD80
7674 | OPTS_TYPE_PT_ADDBITS15
7675 | OPTS_TYPE_ST_HEX;
7676 kern_type = KERN_TYPE_SHA512_SLTPW;
7677 dgst_size = DGST_SIZE_8_8;
7678 parse_func = osx512_parse_hash;
7679 sort_by_digest = sort_by_digest_8_8;
7680 opti_type = OPTI_TYPE_ZERO_BYTE
7681 | OPTI_TYPE_PRECOMPUTE_INIT
7682 | OPTI_TYPE_PRECOMPUTE_MERKLE
7683 | OPTI_TYPE_EARLY_SKIP
7684 | OPTI_TYPE_NOT_ITERATED
7685 | OPTI_TYPE_PREPENDED_SALT
7686 | OPTI_TYPE_RAW_HASH;
7687 dgst_pos0 = 14;
7688 dgst_pos1 = 15;
7689 dgst_pos2 = 6;
7690 dgst_pos3 = 7;
7691 break;
7692
7693 case 1730: hash_type = HASH_TYPE_SHA512;
7694 salt_type = SALT_TYPE_INTERN;
7695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7696 opts_type = OPTS_TYPE_PT_GENERATE_BE
7697 | OPTS_TYPE_PT_UNICODE
7698 | OPTS_TYPE_ST_ADD80
7699 | OPTS_TYPE_ST_ADDBITS15;
7700 kern_type = KERN_TYPE_SHA512_PWSLTU;
7701 dgst_size = DGST_SIZE_8_8;
7702 parse_func = sha512s_parse_hash;
7703 sort_by_digest = sort_by_digest_8_8;
7704 opti_type = OPTI_TYPE_ZERO_BYTE
7705 | OPTI_TYPE_PRECOMPUTE_INIT
7706 | OPTI_TYPE_PRECOMPUTE_MERKLE
7707 | OPTI_TYPE_EARLY_SKIP
7708 | OPTI_TYPE_NOT_ITERATED
7709 | OPTI_TYPE_APPENDED_SALT
7710 | OPTI_TYPE_RAW_HASH;
7711 dgst_pos0 = 14;
7712 dgst_pos1 = 15;
7713 dgst_pos2 = 6;
7714 dgst_pos3 = 7;
7715 break;
7716
7717 case 1731: hash_type = HASH_TYPE_SHA512;
7718 salt_type = SALT_TYPE_EMBEDDED;
7719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7720 opts_type = OPTS_TYPE_PT_GENERATE_BE
7721 | OPTS_TYPE_PT_UNICODE
7722 | OPTS_TYPE_ST_ADD80
7723 | OPTS_TYPE_ST_ADDBITS15
7724 | OPTS_TYPE_ST_HEX;
7725 kern_type = KERN_TYPE_SHA512_PWSLTU;
7726 dgst_size = DGST_SIZE_8_8;
7727 parse_func = mssql2012_parse_hash;
7728 sort_by_digest = sort_by_digest_8_8;
7729 opti_type = OPTI_TYPE_ZERO_BYTE
7730 | OPTI_TYPE_PRECOMPUTE_INIT
7731 | OPTI_TYPE_PRECOMPUTE_MERKLE
7732 | OPTI_TYPE_EARLY_SKIP
7733 | OPTI_TYPE_NOT_ITERATED
7734 | OPTI_TYPE_APPENDED_SALT
7735 | OPTI_TYPE_RAW_HASH;
7736 dgst_pos0 = 14;
7737 dgst_pos1 = 15;
7738 dgst_pos2 = 6;
7739 dgst_pos3 = 7;
7740 break;
7741
7742 case 1740: hash_type = HASH_TYPE_SHA512;
7743 salt_type = SALT_TYPE_INTERN;
7744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7745 opts_type = OPTS_TYPE_PT_GENERATE_BE
7746 | OPTS_TYPE_PT_ADD80
7747 | OPTS_TYPE_PT_ADDBITS15
7748 | OPTS_TYPE_PT_UNICODE;
7749 kern_type = KERN_TYPE_SHA512_SLTPWU;
7750 dgst_size = DGST_SIZE_8_8;
7751 parse_func = sha512s_parse_hash;
7752 sort_by_digest = sort_by_digest_8_8;
7753 opti_type = OPTI_TYPE_ZERO_BYTE
7754 | OPTI_TYPE_PRECOMPUTE_INIT
7755 | OPTI_TYPE_PRECOMPUTE_MERKLE
7756 | OPTI_TYPE_EARLY_SKIP
7757 | OPTI_TYPE_NOT_ITERATED
7758 | OPTI_TYPE_PREPENDED_SALT
7759 | OPTI_TYPE_RAW_HASH;
7760 dgst_pos0 = 14;
7761 dgst_pos1 = 15;
7762 dgst_pos2 = 6;
7763 dgst_pos3 = 7;
7764 break;
7765
7766 case 1750: hash_type = HASH_TYPE_SHA512;
7767 salt_type = SALT_TYPE_INTERN;
7768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7769 opts_type = OPTS_TYPE_PT_GENERATE_BE
7770 | OPTS_TYPE_ST_ADD80;
7771 kern_type = KERN_TYPE_HMACSHA512_PW;
7772 dgst_size = DGST_SIZE_8_8;
7773 parse_func = hmacsha512_parse_hash;
7774 sort_by_digest = sort_by_digest_8_8;
7775 opti_type = OPTI_TYPE_ZERO_BYTE
7776 | OPTI_TYPE_NOT_ITERATED;
7777 dgst_pos0 = 14;
7778 dgst_pos1 = 15;
7779 dgst_pos2 = 6;
7780 dgst_pos3 = 7;
7781 break;
7782
7783 case 1760: hash_type = HASH_TYPE_SHA512;
7784 salt_type = SALT_TYPE_INTERN;
7785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7786 opts_type = OPTS_TYPE_PT_GENERATE_BE
7787 | OPTS_TYPE_PT_ADD80
7788 | OPTS_TYPE_PT_ADDBITS15;
7789 kern_type = KERN_TYPE_HMACSHA512_SLT;
7790 dgst_size = DGST_SIZE_8_8;
7791 parse_func = hmacsha512_parse_hash;
7792 sort_by_digest = sort_by_digest_8_8;
7793 opti_type = OPTI_TYPE_ZERO_BYTE
7794 | OPTI_TYPE_NOT_ITERATED;
7795 dgst_pos0 = 14;
7796 dgst_pos1 = 15;
7797 dgst_pos2 = 6;
7798 dgst_pos3 = 7;
7799 break;
7800
7801 case 1800: hash_type = HASH_TYPE_SHA512;
7802 salt_type = SALT_TYPE_EMBEDDED;
7803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7804 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7805 kern_type = KERN_TYPE_SHA512CRYPT;
7806 dgst_size = DGST_SIZE_8_8;
7807 parse_func = sha512crypt_parse_hash;
7808 sort_by_digest = sort_by_digest_8_8;
7809 opti_type = OPTI_TYPE_ZERO_BYTE;
7810 dgst_pos0 = 0;
7811 dgst_pos1 = 1;
7812 dgst_pos2 = 2;
7813 dgst_pos3 = 3;
7814 break;
7815
7816 case 2100: hash_type = HASH_TYPE_DCC2;
7817 salt_type = SALT_TYPE_EMBEDDED;
7818 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7819 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7820 | OPTS_TYPE_ST_LOWER
7821 | OPTS_TYPE_ST_UNICODE;
7822 kern_type = KERN_TYPE_DCC2;
7823 dgst_size = DGST_SIZE_4_4;
7824 parse_func = dcc2_parse_hash;
7825 sort_by_digest = sort_by_digest_4_4;
7826 opti_type = OPTI_TYPE_ZERO_BYTE;
7827 dgst_pos0 = 0;
7828 dgst_pos1 = 1;
7829 dgst_pos2 = 2;
7830 dgst_pos3 = 3;
7831 break;
7832
7833 case 2400: hash_type = HASH_TYPE_MD5;
7834 salt_type = SALT_TYPE_NONE;
7835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7836 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7837 kern_type = KERN_TYPE_MD5PIX;
7838 dgst_size = DGST_SIZE_4_4;
7839 parse_func = md5pix_parse_hash;
7840 sort_by_digest = sort_by_digest_4_4;
7841 opti_type = OPTI_TYPE_ZERO_BYTE
7842 | OPTI_TYPE_PRECOMPUTE_INIT
7843 | OPTI_TYPE_PRECOMPUTE_MERKLE
7844 | OPTI_TYPE_EARLY_SKIP
7845 | OPTI_TYPE_NOT_ITERATED
7846 | OPTI_TYPE_NOT_SALTED;
7847 dgst_pos0 = 0;
7848 dgst_pos1 = 3;
7849 dgst_pos2 = 2;
7850 dgst_pos3 = 1;
7851 break;
7852
7853 case 2410: hash_type = HASH_TYPE_MD5;
7854 salt_type = SALT_TYPE_INTERN;
7855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7856 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7857 kern_type = KERN_TYPE_MD5ASA;
7858 dgst_size = DGST_SIZE_4_4;
7859 parse_func = md5asa_parse_hash;
7860 sort_by_digest = sort_by_digest_4_4;
7861 opti_type = OPTI_TYPE_ZERO_BYTE
7862 | OPTI_TYPE_PRECOMPUTE_INIT
7863 | OPTI_TYPE_PRECOMPUTE_MERKLE
7864 | OPTI_TYPE_EARLY_SKIP
7865 | OPTI_TYPE_NOT_ITERATED;
7866 dgst_pos0 = 0;
7867 dgst_pos1 = 3;
7868 dgst_pos2 = 2;
7869 dgst_pos3 = 1;
7870 break;
7871
7872 case 2500: hash_type = HASH_TYPE_WPA;
7873 salt_type = SALT_TYPE_EMBEDDED;
7874 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7875 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7876 kern_type = KERN_TYPE_WPA;
7877 dgst_size = DGST_SIZE_4_4;
7878 parse_func = wpa_parse_hash;
7879 sort_by_digest = sort_by_digest_4_4;
7880 opti_type = OPTI_TYPE_ZERO_BYTE;
7881 dgst_pos0 = 0;
7882 dgst_pos1 = 1;
7883 dgst_pos2 = 2;
7884 dgst_pos3 = 3;
7885 break;
7886
7887 case 2600: hash_type = HASH_TYPE_MD5;
7888 salt_type = SALT_TYPE_VIRTUAL;
7889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7890 opts_type = OPTS_TYPE_PT_GENERATE_LE
7891 | OPTS_TYPE_PT_ADD80
7892 | OPTS_TYPE_PT_ADDBITS14
7893 | OPTS_TYPE_ST_ADD80;
7894 kern_type = KERN_TYPE_MD55_PWSLT1;
7895 dgst_size = DGST_SIZE_4_4;
7896 parse_func = md5md5_parse_hash;
7897 sort_by_digest = sort_by_digest_4_4;
7898 opti_type = OPTI_TYPE_ZERO_BYTE
7899 | OPTI_TYPE_PRECOMPUTE_INIT
7900 | OPTI_TYPE_PRECOMPUTE_MERKLE
7901 | OPTI_TYPE_EARLY_SKIP;
7902 dgst_pos0 = 0;
7903 dgst_pos1 = 3;
7904 dgst_pos2 = 2;
7905 dgst_pos3 = 1;
7906 break;
7907
7908 case 2611: hash_type = HASH_TYPE_MD5;
7909 salt_type = SALT_TYPE_INTERN;
7910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7911 opts_type = OPTS_TYPE_PT_GENERATE_LE
7912 | OPTS_TYPE_PT_ADD80
7913 | OPTS_TYPE_PT_ADDBITS14
7914 | OPTS_TYPE_ST_ADD80;
7915 kern_type = KERN_TYPE_MD55_PWSLT1;
7916 dgst_size = DGST_SIZE_4_4;
7917 parse_func = vb3_parse_hash;
7918 sort_by_digest = sort_by_digest_4_4;
7919 opti_type = OPTI_TYPE_ZERO_BYTE
7920 | OPTI_TYPE_PRECOMPUTE_INIT
7921 | OPTI_TYPE_PRECOMPUTE_MERKLE
7922 | OPTI_TYPE_EARLY_SKIP;
7923 dgst_pos0 = 0;
7924 dgst_pos1 = 3;
7925 dgst_pos2 = 2;
7926 dgst_pos3 = 1;
7927 break;
7928
7929 case 2612: hash_type = HASH_TYPE_MD5;
7930 salt_type = SALT_TYPE_EMBEDDED;
7931 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7932 opts_type = OPTS_TYPE_PT_GENERATE_LE
7933 | OPTS_TYPE_PT_ADD80
7934 | OPTS_TYPE_PT_ADDBITS14
7935 | OPTS_TYPE_ST_ADD80
7936 | OPTS_TYPE_ST_HEX;
7937 kern_type = KERN_TYPE_MD55_PWSLT1;
7938 dgst_size = DGST_SIZE_4_4;
7939 parse_func = phps_parse_hash;
7940 sort_by_digest = sort_by_digest_4_4;
7941 opti_type = OPTI_TYPE_ZERO_BYTE
7942 | OPTI_TYPE_PRECOMPUTE_INIT
7943 | OPTI_TYPE_PRECOMPUTE_MERKLE
7944 | OPTI_TYPE_EARLY_SKIP;
7945 dgst_pos0 = 0;
7946 dgst_pos1 = 3;
7947 dgst_pos2 = 2;
7948 dgst_pos3 = 1;
7949 break;
7950
7951 case 2711: hash_type = HASH_TYPE_MD5;
7952 salt_type = SALT_TYPE_INTERN;
7953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7954 opts_type = OPTS_TYPE_PT_GENERATE_LE
7955 | OPTS_TYPE_PT_ADD80
7956 | OPTS_TYPE_PT_ADDBITS14
7957 | OPTS_TYPE_ST_ADD80;
7958 kern_type = KERN_TYPE_MD55_PWSLT2;
7959 dgst_size = DGST_SIZE_4_4;
7960 parse_func = vb30_parse_hash;
7961 sort_by_digest = sort_by_digest_4_4;
7962 opti_type = OPTI_TYPE_ZERO_BYTE
7963 | OPTI_TYPE_PRECOMPUTE_INIT
7964 | OPTI_TYPE_EARLY_SKIP;
7965 dgst_pos0 = 0;
7966 dgst_pos1 = 3;
7967 dgst_pos2 = 2;
7968 dgst_pos3 = 1;
7969 break;
7970
7971 case 2811: hash_type = HASH_TYPE_MD5;
7972 salt_type = SALT_TYPE_INTERN;
7973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7974 opts_type = OPTS_TYPE_PT_GENERATE_LE
7975 | OPTS_TYPE_PT_ADD80
7976 | OPTS_TYPE_PT_ADDBITS14;
7977 kern_type = KERN_TYPE_MD55_SLTPW;
7978 dgst_size = DGST_SIZE_4_4;
7979 parse_func = ipb2_parse_hash;
7980 sort_by_digest = sort_by_digest_4_4;
7981 opti_type = OPTI_TYPE_ZERO_BYTE
7982 | OPTI_TYPE_PRECOMPUTE_INIT
7983 | OPTI_TYPE_EARLY_SKIP;
7984 dgst_pos0 = 0;
7985 dgst_pos1 = 3;
7986 dgst_pos2 = 2;
7987 dgst_pos3 = 1;
7988 break;
7989
7990 case 3000: hash_type = HASH_TYPE_LM;
7991 salt_type = SALT_TYPE_NONE;
7992 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7993 opts_type = OPTS_TYPE_PT_GENERATE_LE
7994 | OPTS_TYPE_PT_UPPER
7995 | OPTS_TYPE_PT_BITSLICE;
7996 kern_type = KERN_TYPE_LM;
7997 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7998 parse_func = lm_parse_hash;
7999 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8000 opti_type = OPTI_TYPE_ZERO_BYTE
8001 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8002 dgst_pos0 = 0;
8003 dgst_pos1 = 1;
8004 dgst_pos2 = 2;
8005 dgst_pos3 = 3;
8006 break;
8007
8008 case 3100: hash_type = HASH_TYPE_ORACLEH;
8009 salt_type = SALT_TYPE_INTERN;
8010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8011 opts_type = OPTS_TYPE_PT_GENERATE_LE
8012 | OPTS_TYPE_PT_UPPER
8013 | OPTS_TYPE_ST_UPPER;
8014 kern_type = KERN_TYPE_ORACLEH;
8015 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8016 parse_func = oracleh_parse_hash;
8017 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8018 opti_type = OPTI_TYPE_ZERO_BYTE;
8019 dgst_pos0 = 0;
8020 dgst_pos1 = 1;
8021 dgst_pos2 = 2;
8022 dgst_pos3 = 3;
8023 break;
8024
8025 case 3200: hash_type = HASH_TYPE_BCRYPT;
8026 salt_type = SALT_TYPE_EMBEDDED;
8027 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8028 opts_type = OPTS_TYPE_PT_GENERATE_LE
8029 | OPTS_TYPE_ST_GENERATE_LE;
8030 kern_type = KERN_TYPE_BCRYPT;
8031 dgst_size = DGST_SIZE_4_6;
8032 parse_func = bcrypt_parse_hash;
8033 sort_by_digest = sort_by_digest_4_6;
8034 opti_type = OPTI_TYPE_ZERO_BYTE;
8035 dgst_pos0 = 0;
8036 dgst_pos1 = 1;
8037 dgst_pos2 = 2;
8038 dgst_pos3 = 3;
8039 break;
8040
8041 case 3710: hash_type = HASH_TYPE_MD5;
8042 salt_type = SALT_TYPE_INTERN;
8043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8044 opts_type = OPTS_TYPE_PT_GENERATE_LE
8045 | OPTS_TYPE_PT_ADD80
8046 | OPTS_TYPE_PT_ADDBITS14;
8047 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8048 dgst_size = DGST_SIZE_4_4;
8049 parse_func = md5s_parse_hash;
8050 sort_by_digest = sort_by_digest_4_4;
8051 opti_type = OPTI_TYPE_ZERO_BYTE
8052 | OPTI_TYPE_PRECOMPUTE_INIT
8053 | OPTI_TYPE_PRECOMPUTE_MERKLE
8054 | OPTI_TYPE_EARLY_SKIP;
8055 dgst_pos0 = 0;
8056 dgst_pos1 = 3;
8057 dgst_pos2 = 2;
8058 dgst_pos3 = 1;
8059 break;
8060
8061 case 3711: hash_type = HASH_TYPE_MD5;
8062 salt_type = SALT_TYPE_EMBEDDED;
8063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8064 opts_type = OPTS_TYPE_PT_GENERATE_LE
8065 | OPTS_TYPE_PT_ADD80
8066 | OPTS_TYPE_PT_ADDBITS14;
8067 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8068 dgst_size = DGST_SIZE_4_4;
8069 parse_func = mediawiki_b_parse_hash;
8070 sort_by_digest = sort_by_digest_4_4;
8071 opti_type = OPTI_TYPE_ZERO_BYTE
8072 | OPTI_TYPE_PRECOMPUTE_INIT
8073 | OPTI_TYPE_PRECOMPUTE_MERKLE
8074 | OPTI_TYPE_EARLY_SKIP;
8075 dgst_pos0 = 0;
8076 dgst_pos1 = 3;
8077 dgst_pos2 = 2;
8078 dgst_pos3 = 1;
8079 break;
8080
8081 case 3800: hash_type = HASH_TYPE_MD5;
8082 salt_type = SALT_TYPE_INTERN;
8083 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8084 opts_type = OPTS_TYPE_PT_GENERATE_LE
8085 | OPTS_TYPE_ST_ADDBITS14;
8086 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8087 dgst_size = DGST_SIZE_4_4;
8088 parse_func = md5s_parse_hash;
8089 sort_by_digest = sort_by_digest_4_4;
8090 opti_type = OPTI_TYPE_ZERO_BYTE
8091 | OPTI_TYPE_PRECOMPUTE_INIT
8092 | OPTI_TYPE_PRECOMPUTE_MERKLE
8093 | OPTI_TYPE_EARLY_SKIP
8094 | OPTI_TYPE_NOT_ITERATED
8095 | OPTI_TYPE_RAW_HASH;
8096 dgst_pos0 = 0;
8097 dgst_pos1 = 3;
8098 dgst_pos2 = 2;
8099 dgst_pos3 = 1;
8100 break;
8101
8102 case 4300: hash_type = HASH_TYPE_MD5;
8103 salt_type = SALT_TYPE_VIRTUAL;
8104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8105 opts_type = OPTS_TYPE_PT_GENERATE_LE
8106 | OPTS_TYPE_PT_ADD80
8107 | OPTS_TYPE_PT_ADDBITS14
8108 | OPTS_TYPE_ST_ADD80;
8109 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8110 dgst_size = DGST_SIZE_4_4;
8111 parse_func = md5md5_parse_hash;
8112 sort_by_digest = sort_by_digest_4_4;
8113 opti_type = OPTI_TYPE_ZERO_BYTE
8114 | OPTI_TYPE_PRECOMPUTE_INIT
8115 | OPTI_TYPE_PRECOMPUTE_MERKLE
8116 | OPTI_TYPE_EARLY_SKIP;
8117 dgst_pos0 = 0;
8118 dgst_pos1 = 3;
8119 dgst_pos2 = 2;
8120 dgst_pos3 = 1;
8121 break;
8122
8123
8124 case 4400: hash_type = HASH_TYPE_MD5;
8125 salt_type = SALT_TYPE_NONE;
8126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8127 opts_type = OPTS_TYPE_PT_GENERATE_BE
8128 | OPTS_TYPE_PT_ADD80
8129 | OPTS_TYPE_PT_ADDBITS15;
8130 kern_type = KERN_TYPE_MD5_SHA1;
8131 dgst_size = DGST_SIZE_4_4;
8132 parse_func = md5_parse_hash;
8133 sort_by_digest = sort_by_digest_4_4;
8134 opti_type = OPTI_TYPE_ZERO_BYTE
8135 | OPTI_TYPE_PRECOMPUTE_INIT
8136 | OPTI_TYPE_PRECOMPUTE_MERKLE
8137 | OPTI_TYPE_EARLY_SKIP
8138 | OPTI_TYPE_NOT_ITERATED
8139 | OPTI_TYPE_NOT_SALTED
8140 | OPTI_TYPE_RAW_HASH;
8141 dgst_pos0 = 0;
8142 dgst_pos1 = 3;
8143 dgst_pos2 = 2;
8144 dgst_pos3 = 1;
8145 break;
8146
8147 case 4500: hash_type = HASH_TYPE_SHA1;
8148 salt_type = SALT_TYPE_NONE;
8149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8150 opts_type = OPTS_TYPE_PT_GENERATE_BE
8151 | OPTS_TYPE_PT_ADD80
8152 | OPTS_TYPE_PT_ADDBITS15;
8153 kern_type = KERN_TYPE_SHA11;
8154 dgst_size = DGST_SIZE_4_5;
8155 parse_func = sha1_parse_hash;
8156 sort_by_digest = sort_by_digest_4_5;
8157 opti_type = OPTI_TYPE_ZERO_BYTE
8158 | OPTI_TYPE_PRECOMPUTE_INIT
8159 | OPTI_TYPE_PRECOMPUTE_MERKLE
8160 | OPTI_TYPE_EARLY_SKIP
8161 | OPTI_TYPE_NOT_SALTED;
8162 dgst_pos0 = 3;
8163 dgst_pos1 = 4;
8164 dgst_pos2 = 2;
8165 dgst_pos3 = 1;
8166 break;
8167
8168 case 4700: hash_type = HASH_TYPE_SHA1;
8169 salt_type = SALT_TYPE_NONE;
8170 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8171 opts_type = OPTS_TYPE_PT_GENERATE_LE
8172 | OPTS_TYPE_PT_ADD80
8173 | OPTS_TYPE_PT_ADDBITS14;
8174 kern_type = KERN_TYPE_SHA1_MD5;
8175 dgst_size = DGST_SIZE_4_5;
8176 parse_func = sha1_parse_hash;
8177 sort_by_digest = sort_by_digest_4_5;
8178 opti_type = OPTI_TYPE_ZERO_BYTE
8179 | OPTI_TYPE_PRECOMPUTE_INIT
8180 | OPTI_TYPE_PRECOMPUTE_MERKLE
8181 | OPTI_TYPE_EARLY_SKIP
8182 | OPTI_TYPE_NOT_ITERATED
8183 | OPTI_TYPE_NOT_SALTED
8184 | OPTI_TYPE_RAW_HASH;
8185 dgst_pos0 = 3;
8186 dgst_pos1 = 4;
8187 dgst_pos2 = 2;
8188 dgst_pos3 = 1;
8189 break;
8190
8191 case 4800: hash_type = HASH_TYPE_MD5;
8192 salt_type = SALT_TYPE_EMBEDDED;
8193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8194 opts_type = OPTS_TYPE_PT_GENERATE_LE
8195 | OPTS_TYPE_PT_ADDBITS14;
8196 kern_type = KERN_TYPE_MD5_CHAP;
8197 dgst_size = DGST_SIZE_4_4;
8198 parse_func = chap_parse_hash;
8199 sort_by_digest = sort_by_digest_4_4;
8200 opti_type = OPTI_TYPE_ZERO_BYTE
8201 | OPTI_TYPE_PRECOMPUTE_INIT
8202 | OPTI_TYPE_PRECOMPUTE_MERKLE
8203 | OPTI_TYPE_MEET_IN_MIDDLE
8204 | OPTI_TYPE_EARLY_SKIP
8205 | OPTI_TYPE_NOT_ITERATED
8206 | OPTI_TYPE_RAW_HASH;
8207 dgst_pos0 = 0;
8208 dgst_pos1 = 3;
8209 dgst_pos2 = 2;
8210 dgst_pos3 = 1;
8211 break;
8212
8213 case 4900: hash_type = HASH_TYPE_SHA1;
8214 salt_type = SALT_TYPE_INTERN;
8215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8216 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8217 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8218 dgst_size = DGST_SIZE_4_5;
8219 parse_func = sha1s_parse_hash;
8220 sort_by_digest = sort_by_digest_4_5;
8221 opti_type = OPTI_TYPE_ZERO_BYTE
8222 | OPTI_TYPE_PRECOMPUTE_INIT
8223 | OPTI_TYPE_PRECOMPUTE_MERKLE
8224 | OPTI_TYPE_EARLY_SKIP;
8225 dgst_pos0 = 3;
8226 dgst_pos1 = 4;
8227 dgst_pos2 = 2;
8228 dgst_pos3 = 1;
8229 break;
8230
8231 case 5000: hash_type = HASH_TYPE_KECCAK;
8232 salt_type = SALT_TYPE_EMBEDDED;
8233 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8234 opts_type = OPTS_TYPE_PT_GENERATE_LE
8235 | OPTS_TYPE_PT_ADD01;
8236 kern_type = KERN_TYPE_KECCAK;
8237 dgst_size = DGST_SIZE_8_25;
8238 parse_func = keccak_parse_hash;
8239 sort_by_digest = sort_by_digest_8_25;
8240 opti_type = OPTI_TYPE_ZERO_BYTE
8241 | OPTI_TYPE_RAW_HASH;
8242 dgst_pos0 = 2;
8243 dgst_pos1 = 3;
8244 dgst_pos2 = 4;
8245 dgst_pos3 = 5;
8246 break;
8247
8248 case 5100: hash_type = HASH_TYPE_MD5H;
8249 salt_type = SALT_TYPE_NONE;
8250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8251 opts_type = OPTS_TYPE_PT_GENERATE_LE
8252 | OPTS_TYPE_PT_ADD80
8253 | OPTS_TYPE_PT_ADDBITS14;
8254 kern_type = KERN_TYPE_MD5H;
8255 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8256 parse_func = md5half_parse_hash;
8257 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8258 opti_type = OPTI_TYPE_ZERO_BYTE
8259 | OPTI_TYPE_RAW_HASH;
8260 dgst_pos0 = 0;
8261 dgst_pos1 = 1;
8262 dgst_pos2 = 2;
8263 dgst_pos3 = 3;
8264 break;
8265
8266 case 5200: hash_type = HASH_TYPE_SHA256;
8267 salt_type = SALT_TYPE_EMBEDDED;
8268 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8269 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8270 kern_type = KERN_TYPE_PSAFE3;
8271 dgst_size = DGST_SIZE_4_8;
8272 parse_func = psafe3_parse_hash;
8273 sort_by_digest = sort_by_digest_4_8;
8274 opti_type = OPTI_TYPE_ZERO_BYTE;
8275 dgst_pos0 = 0;
8276 dgst_pos1 = 1;
8277 dgst_pos2 = 2;
8278 dgst_pos3 = 3;
8279 break;
8280
8281 case 5300: hash_type = HASH_TYPE_MD5;
8282 salt_type = SALT_TYPE_EMBEDDED;
8283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8284 opts_type = OPTS_TYPE_PT_GENERATE_LE
8285 | OPTS_TYPE_ST_ADD80;
8286 kern_type = KERN_TYPE_IKEPSK_MD5;
8287 dgst_size = DGST_SIZE_4_4;
8288 parse_func = ikepsk_md5_parse_hash;
8289 sort_by_digest = sort_by_digest_4_4;
8290 opti_type = OPTI_TYPE_ZERO_BYTE;
8291 dgst_pos0 = 0;
8292 dgst_pos1 = 3;
8293 dgst_pos2 = 2;
8294 dgst_pos3 = 1;
8295 break;
8296
8297 case 5400: hash_type = HASH_TYPE_SHA1;
8298 salt_type = SALT_TYPE_EMBEDDED;
8299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8300 opts_type = OPTS_TYPE_PT_GENERATE_BE
8301 | OPTS_TYPE_ST_ADD80;
8302 kern_type = KERN_TYPE_IKEPSK_SHA1;
8303 dgst_size = DGST_SIZE_4_5;
8304 parse_func = ikepsk_sha1_parse_hash;
8305 sort_by_digest = sort_by_digest_4_5;
8306 opti_type = OPTI_TYPE_ZERO_BYTE;
8307 dgst_pos0 = 3;
8308 dgst_pos1 = 4;
8309 dgst_pos2 = 2;
8310 dgst_pos3 = 1;
8311 break;
8312
8313 case 5500: hash_type = HASH_TYPE_NETNTLM;
8314 salt_type = SALT_TYPE_EMBEDDED;
8315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8316 opts_type = OPTS_TYPE_PT_GENERATE_LE
8317 | OPTS_TYPE_PT_ADD80
8318 | OPTS_TYPE_PT_ADDBITS14
8319 | OPTS_TYPE_PT_UNICODE
8320 | OPTS_TYPE_ST_HEX;
8321 kern_type = KERN_TYPE_NETNTLMv1;
8322 dgst_size = DGST_SIZE_4_4;
8323 parse_func = netntlmv1_parse_hash;
8324 sort_by_digest = sort_by_digest_4_4;
8325 opti_type = OPTI_TYPE_ZERO_BYTE
8326 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8327 dgst_pos0 = 0;
8328 dgst_pos1 = 1;
8329 dgst_pos2 = 2;
8330 dgst_pos3 = 3;
8331 break;
8332
8333 case 5600: hash_type = HASH_TYPE_MD5;
8334 salt_type = SALT_TYPE_EMBEDDED;
8335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8336 opts_type = OPTS_TYPE_PT_GENERATE_LE
8337 | OPTS_TYPE_PT_ADD80
8338 | OPTS_TYPE_PT_ADDBITS14
8339 | OPTS_TYPE_PT_UNICODE;
8340 kern_type = KERN_TYPE_NETNTLMv2;
8341 dgst_size = DGST_SIZE_4_4;
8342 parse_func = netntlmv2_parse_hash;
8343 sort_by_digest = sort_by_digest_4_4;
8344 opti_type = OPTI_TYPE_ZERO_BYTE;
8345 dgst_pos0 = 0;
8346 dgst_pos1 = 3;
8347 dgst_pos2 = 2;
8348 dgst_pos3 = 1;
8349 break;
8350
8351 case 5700: hash_type = HASH_TYPE_SHA256;
8352 salt_type = SALT_TYPE_NONE;
8353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8354 opts_type = OPTS_TYPE_PT_GENERATE_BE
8355 | OPTS_TYPE_PT_ADD80
8356 | OPTS_TYPE_PT_ADDBITS15;
8357 kern_type = KERN_TYPE_SHA256;
8358 dgst_size = DGST_SIZE_4_8;
8359 parse_func = cisco4_parse_hash;
8360 sort_by_digest = sort_by_digest_4_8;
8361 opti_type = OPTI_TYPE_ZERO_BYTE
8362 | OPTI_TYPE_PRECOMPUTE_INIT
8363 | OPTI_TYPE_PRECOMPUTE_MERKLE
8364 | OPTI_TYPE_EARLY_SKIP
8365 | OPTI_TYPE_NOT_ITERATED
8366 | OPTI_TYPE_NOT_SALTED
8367 | OPTI_TYPE_RAW_HASH;
8368 dgst_pos0 = 3;
8369 dgst_pos1 = 7;
8370 dgst_pos2 = 2;
8371 dgst_pos3 = 6;
8372 break;
8373
8374 case 5800: hash_type = HASH_TYPE_SHA1;
8375 salt_type = SALT_TYPE_INTERN;
8376 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8377 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8378 | OPTS_TYPE_ST_ADD80;
8379 kern_type = KERN_TYPE_ANDROIDPIN;
8380 dgst_size = DGST_SIZE_4_5;
8381 parse_func = androidpin_parse_hash;
8382 sort_by_digest = sort_by_digest_4_5;
8383 opti_type = OPTI_TYPE_ZERO_BYTE;
8384 dgst_pos0 = 0;
8385 dgst_pos1 = 1;
8386 dgst_pos2 = 2;
8387 dgst_pos3 = 3;
8388 break;
8389
8390 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8391 salt_type = SALT_TYPE_NONE;
8392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8393 opts_type = OPTS_TYPE_PT_GENERATE_LE
8394 | OPTS_TYPE_PT_ADD80;
8395 kern_type = KERN_TYPE_RIPEMD160;
8396 dgst_size = DGST_SIZE_4_5;
8397 parse_func = ripemd160_parse_hash;
8398 sort_by_digest = sort_by_digest_4_5;
8399 opti_type = OPTI_TYPE_ZERO_BYTE;
8400 dgst_pos0 = 0;
8401 dgst_pos1 = 1;
8402 dgst_pos2 = 2;
8403 dgst_pos3 = 3;
8404 break;
8405
8406 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8407 salt_type = SALT_TYPE_NONE;
8408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8409 opts_type = OPTS_TYPE_PT_GENERATE_BE
8410 | OPTS_TYPE_PT_ADD80;
8411 kern_type = KERN_TYPE_WHIRLPOOL;
8412 dgst_size = DGST_SIZE_4_16;
8413 parse_func = whirlpool_parse_hash;
8414 sort_by_digest = sort_by_digest_4_16;
8415 opti_type = OPTI_TYPE_ZERO_BYTE;
8416 dgst_pos0 = 0;
8417 dgst_pos1 = 1;
8418 dgst_pos2 = 2;
8419 dgst_pos3 = 3;
8420 break;
8421
8422 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8423 salt_type = SALT_TYPE_EMBEDDED;
8424 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8425 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8426 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8427 dgst_size = DGST_SIZE_4_5;
8428 parse_func = truecrypt_parse_hash_2k;
8429 sort_by_digest = sort_by_digest_4_5;
8430 opti_type = OPTI_TYPE_ZERO_BYTE;
8431 dgst_pos0 = 0;
8432 dgst_pos1 = 1;
8433 dgst_pos2 = 2;
8434 dgst_pos3 = 3;
8435 break;
8436
8437 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8438 salt_type = SALT_TYPE_EMBEDDED;
8439 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8440 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8441 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8442 dgst_size = DGST_SIZE_4_5;
8443 parse_func = truecrypt_parse_hash_2k;
8444 sort_by_digest = sort_by_digest_4_5;
8445 opti_type = OPTI_TYPE_ZERO_BYTE;
8446 dgst_pos0 = 0;
8447 dgst_pos1 = 1;
8448 dgst_pos2 = 2;
8449 dgst_pos3 = 3;
8450 break;
8451
8452 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8453 salt_type = SALT_TYPE_EMBEDDED;
8454 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8455 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8456 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8457 dgst_size = DGST_SIZE_4_5;
8458 parse_func = truecrypt_parse_hash_2k;
8459 sort_by_digest = sort_by_digest_4_5;
8460 opti_type = OPTI_TYPE_ZERO_BYTE;
8461 dgst_pos0 = 0;
8462 dgst_pos1 = 1;
8463 dgst_pos2 = 2;
8464 dgst_pos3 = 3;
8465 break;
8466
8467 case 6221: hash_type = HASH_TYPE_SHA512;
8468 salt_type = SALT_TYPE_EMBEDDED;
8469 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8470 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8471 kern_type = KERN_TYPE_TCSHA512_XTS512;
8472 dgst_size = DGST_SIZE_8_8;
8473 parse_func = truecrypt_parse_hash_1k;
8474 sort_by_digest = sort_by_digest_8_8;
8475 opti_type = OPTI_TYPE_ZERO_BYTE;
8476 dgst_pos0 = 0;
8477 dgst_pos1 = 1;
8478 dgst_pos2 = 2;
8479 dgst_pos3 = 3;
8480 break;
8481
8482 case 6222: hash_type = HASH_TYPE_SHA512;
8483 salt_type = SALT_TYPE_EMBEDDED;
8484 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8485 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8486 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8487 dgst_size = DGST_SIZE_8_8;
8488 parse_func = truecrypt_parse_hash_1k;
8489 sort_by_digest = sort_by_digest_8_8;
8490 opti_type = OPTI_TYPE_ZERO_BYTE;
8491 dgst_pos0 = 0;
8492 dgst_pos1 = 1;
8493 dgst_pos2 = 2;
8494 dgst_pos3 = 3;
8495 break;
8496
8497 case 6223: hash_type = HASH_TYPE_SHA512;
8498 salt_type = SALT_TYPE_EMBEDDED;
8499 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8500 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8501 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8502 dgst_size = DGST_SIZE_8_8;
8503 parse_func = truecrypt_parse_hash_1k;
8504 sort_by_digest = sort_by_digest_8_8;
8505 opti_type = OPTI_TYPE_ZERO_BYTE;
8506 dgst_pos0 = 0;
8507 dgst_pos1 = 1;
8508 dgst_pos2 = 2;
8509 dgst_pos3 = 3;
8510 break;
8511
8512 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8513 salt_type = SALT_TYPE_EMBEDDED;
8514 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8515 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8516 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8517 dgst_size = DGST_SIZE_4_8;
8518 parse_func = truecrypt_parse_hash_1k;
8519 sort_by_digest = sort_by_digest_4_8;
8520 opti_type = OPTI_TYPE_ZERO_BYTE;
8521 dgst_pos0 = 0;
8522 dgst_pos1 = 1;
8523 dgst_pos2 = 2;
8524 dgst_pos3 = 3;
8525 break;
8526
8527 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8528 salt_type = SALT_TYPE_EMBEDDED;
8529 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8530 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8531 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8532 dgst_size = DGST_SIZE_4_8;
8533 parse_func = truecrypt_parse_hash_1k;
8534 sort_by_digest = sort_by_digest_4_8;
8535 opti_type = OPTI_TYPE_ZERO_BYTE;
8536 dgst_pos0 = 0;
8537 dgst_pos1 = 1;
8538 dgst_pos2 = 2;
8539 dgst_pos3 = 3;
8540 break;
8541
8542 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8543 salt_type = SALT_TYPE_EMBEDDED;
8544 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8545 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8546 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8547 dgst_size = DGST_SIZE_4_8;
8548 parse_func = truecrypt_parse_hash_1k;
8549 sort_by_digest = sort_by_digest_4_8;
8550 opti_type = OPTI_TYPE_ZERO_BYTE;
8551 dgst_pos0 = 0;
8552 dgst_pos1 = 1;
8553 dgst_pos2 = 2;
8554 dgst_pos3 = 3;
8555 break;
8556
8557 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8558 salt_type = SALT_TYPE_EMBEDDED;
8559 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8560 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8561 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8562 dgst_size = DGST_SIZE_4_5;
8563 parse_func = truecrypt_parse_hash_1k;
8564 sort_by_digest = sort_by_digest_4_5;
8565 opti_type = OPTI_TYPE_ZERO_BYTE;
8566 dgst_pos0 = 0;
8567 dgst_pos1 = 1;
8568 dgst_pos2 = 2;
8569 dgst_pos3 = 3;
8570 break;
8571
8572 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8573 salt_type = SALT_TYPE_EMBEDDED;
8574 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8575 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8576 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8577 dgst_size = DGST_SIZE_4_5;
8578 parse_func = truecrypt_parse_hash_1k;
8579 sort_by_digest = sort_by_digest_4_5;
8580 opti_type = OPTI_TYPE_ZERO_BYTE;
8581 dgst_pos0 = 0;
8582 dgst_pos1 = 1;
8583 dgst_pos2 = 2;
8584 dgst_pos3 = 3;
8585 break;
8586
8587 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8588 salt_type = SALT_TYPE_EMBEDDED;
8589 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8590 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8591 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8592 dgst_size = DGST_SIZE_4_5;
8593 parse_func = truecrypt_parse_hash_1k;
8594 sort_by_digest = sort_by_digest_4_5;
8595 opti_type = OPTI_TYPE_ZERO_BYTE;
8596 dgst_pos0 = 0;
8597 dgst_pos1 = 1;
8598 dgst_pos2 = 2;
8599 dgst_pos3 = 3;
8600 break;
8601
8602 case 6300: hash_type = HASH_TYPE_MD5;
8603 salt_type = SALT_TYPE_EMBEDDED;
8604 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8605 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8606 kern_type = KERN_TYPE_MD5AIX;
8607 dgst_size = DGST_SIZE_4_4;
8608 parse_func = md5aix_parse_hash;
8609 sort_by_digest = sort_by_digest_4_4;
8610 opti_type = OPTI_TYPE_ZERO_BYTE;
8611 dgst_pos0 = 0;
8612 dgst_pos1 = 1;
8613 dgst_pos2 = 2;
8614 dgst_pos3 = 3;
8615 break;
8616
8617 case 6400: hash_type = HASH_TYPE_SHA256;
8618 salt_type = SALT_TYPE_EMBEDDED;
8619 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8620 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8621 kern_type = KERN_TYPE_SHA256AIX;
8622 dgst_size = DGST_SIZE_4_8;
8623 parse_func = sha256aix_parse_hash;
8624 sort_by_digest = sort_by_digest_4_8;
8625 opti_type = OPTI_TYPE_ZERO_BYTE;
8626 dgst_pos0 = 0;
8627 dgst_pos1 = 1;
8628 dgst_pos2 = 2;
8629 dgst_pos3 = 3;
8630 break;
8631
8632 case 6500: hash_type = HASH_TYPE_SHA512;
8633 salt_type = SALT_TYPE_EMBEDDED;
8634 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8635 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8636 kern_type = KERN_TYPE_SHA512AIX;
8637 dgst_size = DGST_SIZE_8_8;
8638 parse_func = sha512aix_parse_hash;
8639 sort_by_digest = sort_by_digest_8_8;
8640 opti_type = OPTI_TYPE_ZERO_BYTE;
8641 dgst_pos0 = 0;
8642 dgst_pos1 = 1;
8643 dgst_pos2 = 2;
8644 dgst_pos3 = 3;
8645 break;
8646
8647 case 6600: hash_type = HASH_TYPE_AES;
8648 salt_type = SALT_TYPE_EMBEDDED;
8649 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8650 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8651 kern_type = KERN_TYPE_AGILEKEY;
8652 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8653 parse_func = agilekey_parse_hash;
8654 sort_by_digest = sort_by_digest_4_5;
8655 opti_type = OPTI_TYPE_ZERO_BYTE;
8656 dgst_pos0 = 0;
8657 dgst_pos1 = 1;
8658 dgst_pos2 = 2;
8659 dgst_pos3 = 3;
8660 break;
8661
8662 case 6700: hash_type = HASH_TYPE_SHA1;
8663 salt_type = SALT_TYPE_EMBEDDED;
8664 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8665 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8666 kern_type = KERN_TYPE_SHA1AIX;
8667 dgst_size = DGST_SIZE_4_5;
8668 parse_func = sha1aix_parse_hash;
8669 sort_by_digest = sort_by_digest_4_5;
8670 opti_type = OPTI_TYPE_ZERO_BYTE;
8671 dgst_pos0 = 0;
8672 dgst_pos1 = 1;
8673 dgst_pos2 = 2;
8674 dgst_pos3 = 3;
8675 break;
8676
8677 case 6800: hash_type = HASH_TYPE_AES;
8678 salt_type = SALT_TYPE_EMBEDDED;
8679 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8680 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8681 kern_type = KERN_TYPE_LASTPASS;
8682 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8683 parse_func = lastpass_parse_hash;
8684 sort_by_digest = sort_by_digest_4_8;
8685 opti_type = OPTI_TYPE_ZERO_BYTE;
8686 dgst_pos0 = 0;
8687 dgst_pos1 = 1;
8688 dgst_pos2 = 2;
8689 dgst_pos3 = 3;
8690 break;
8691
8692 case 6900: hash_type = HASH_TYPE_GOST;
8693 salt_type = SALT_TYPE_NONE;
8694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8695 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8696 kern_type = KERN_TYPE_GOST;
8697 dgst_size = DGST_SIZE_4_8;
8698 parse_func = gost_parse_hash;
8699 sort_by_digest = sort_by_digest_4_8;
8700 opti_type = OPTI_TYPE_ZERO_BYTE;
8701 dgst_pos0 = 0;
8702 dgst_pos1 = 1;
8703 dgst_pos2 = 2;
8704 dgst_pos3 = 3;
8705 break;
8706
8707 case 7100: hash_type = HASH_TYPE_SHA512;
8708 salt_type = SALT_TYPE_EMBEDDED;
8709 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8710 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8711 kern_type = KERN_TYPE_PBKDF2_SHA512;
8712 dgst_size = DGST_SIZE_8_16;
8713 parse_func = sha512osx_parse_hash;
8714 sort_by_digest = sort_by_digest_8_16;
8715 opti_type = OPTI_TYPE_ZERO_BYTE;
8716 dgst_pos0 = 0;
8717 dgst_pos1 = 1;
8718 dgst_pos2 = 2;
8719 dgst_pos3 = 3;
8720 break;
8721
8722 case 7200: hash_type = HASH_TYPE_SHA512;
8723 salt_type = SALT_TYPE_EMBEDDED;
8724 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8725 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8726 kern_type = KERN_TYPE_PBKDF2_SHA512;
8727 dgst_size = DGST_SIZE_8_16;
8728 parse_func = sha512grub_parse_hash;
8729 sort_by_digest = sort_by_digest_8_16;
8730 opti_type = OPTI_TYPE_ZERO_BYTE;
8731 dgst_pos0 = 0;
8732 dgst_pos1 = 1;
8733 dgst_pos2 = 2;
8734 dgst_pos3 = 3;
8735 break;
8736
8737 case 7300: hash_type = HASH_TYPE_SHA1;
8738 salt_type = SALT_TYPE_EMBEDDED;
8739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8740 opts_type = OPTS_TYPE_PT_GENERATE_BE
8741 | OPTS_TYPE_ST_ADD80
8742 | OPTS_TYPE_ST_ADDBITS15;
8743 kern_type = KERN_TYPE_RAKP;
8744 dgst_size = DGST_SIZE_4_5;
8745 parse_func = rakp_parse_hash;
8746 sort_by_digest = sort_by_digest_4_5;
8747 opti_type = OPTI_TYPE_ZERO_BYTE
8748 | OPTI_TYPE_NOT_ITERATED;
8749 dgst_pos0 = 3;
8750 dgst_pos1 = 4;
8751 dgst_pos2 = 2;
8752 dgst_pos3 = 1;
8753 break;
8754
8755 case 7400: hash_type = HASH_TYPE_SHA256;
8756 salt_type = SALT_TYPE_EMBEDDED;
8757 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8758 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8759 kern_type = KERN_TYPE_SHA256CRYPT;
8760 dgst_size = DGST_SIZE_4_8;
8761 parse_func = sha256crypt_parse_hash;
8762 sort_by_digest = sort_by_digest_4_8;
8763 opti_type = OPTI_TYPE_ZERO_BYTE;
8764 dgst_pos0 = 0;
8765 dgst_pos1 = 1;
8766 dgst_pos2 = 2;
8767 dgst_pos3 = 3;
8768 break;
8769
8770 case 7500: hash_type = HASH_TYPE_KRB5PA;
8771 salt_type = SALT_TYPE_EMBEDDED;
8772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8773 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8774 kern_type = KERN_TYPE_KRB5PA;
8775 dgst_size = DGST_SIZE_4_4;
8776 parse_func = krb5pa_parse_hash;
8777 sort_by_digest = sort_by_digest_4_4;
8778 opti_type = OPTI_TYPE_ZERO_BYTE
8779 | OPTI_TYPE_NOT_ITERATED;
8780 dgst_pos0 = 3;
8781 dgst_pos1 = 7;
8782 dgst_pos2 = 2;
8783 dgst_pos3 = 6;
8784 break;
8785
8786 case 7600: hash_type = HASH_TYPE_SHA1;
8787 salt_type = SALT_TYPE_INTERN;
8788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8789 opts_type = OPTS_TYPE_PT_GENERATE_BE
8790 | OPTS_TYPE_PT_ADD80
8791 | OPTS_TYPE_PT_ADDBITS15;
8792 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8793 dgst_size = DGST_SIZE_4_5;
8794 parse_func = redmine_parse_hash;
8795 sort_by_digest = sort_by_digest_4_5;
8796 opti_type = OPTI_TYPE_ZERO_BYTE
8797 | OPTI_TYPE_PRECOMPUTE_INIT
8798 | OPTI_TYPE_EARLY_SKIP
8799 | OPTI_TYPE_NOT_ITERATED
8800 | OPTI_TYPE_PREPENDED_SALT;
8801 dgst_pos0 = 3;
8802 dgst_pos1 = 4;
8803 dgst_pos2 = 2;
8804 dgst_pos3 = 1;
8805 break;
8806
8807 case 7700: hash_type = HASH_TYPE_SAPB;
8808 salt_type = SALT_TYPE_EMBEDDED;
8809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8810 opts_type = OPTS_TYPE_PT_GENERATE_LE
8811 | OPTS_TYPE_PT_UPPER
8812 | OPTS_TYPE_ST_UPPER;
8813 kern_type = KERN_TYPE_SAPB;
8814 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8815 parse_func = sapb_parse_hash;
8816 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8817 opti_type = OPTI_TYPE_ZERO_BYTE
8818 | OPTI_TYPE_PRECOMPUTE_INIT
8819 | OPTI_TYPE_NOT_ITERATED;
8820 dgst_pos0 = 0;
8821 dgst_pos1 = 1;
8822 dgst_pos2 = 2;
8823 dgst_pos3 = 3;
8824 break;
8825
8826 case 7800: hash_type = HASH_TYPE_SAPG;
8827 salt_type = SALT_TYPE_EMBEDDED;
8828 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8829 opts_type = OPTS_TYPE_PT_GENERATE_BE
8830 | OPTS_TYPE_ST_ADD80
8831 | OPTS_TYPE_ST_UPPER;
8832 kern_type = KERN_TYPE_SAPG;
8833 dgst_size = DGST_SIZE_4_5;
8834 parse_func = sapg_parse_hash;
8835 sort_by_digest = sort_by_digest_4_5;
8836 opti_type = OPTI_TYPE_ZERO_BYTE
8837 | OPTI_TYPE_PRECOMPUTE_INIT
8838 | OPTI_TYPE_NOT_ITERATED;
8839 dgst_pos0 = 3;
8840 dgst_pos1 = 4;
8841 dgst_pos2 = 2;
8842 dgst_pos3 = 1;
8843 break;
8844
8845 case 7900: hash_type = HASH_TYPE_SHA512;
8846 salt_type = SALT_TYPE_EMBEDDED;
8847 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8848 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8849 kern_type = KERN_TYPE_DRUPAL7;
8850 dgst_size = DGST_SIZE_8_8;
8851 parse_func = drupal7_parse_hash;
8852 sort_by_digest = sort_by_digest_8_8;
8853 opti_type = OPTI_TYPE_ZERO_BYTE;
8854 dgst_pos0 = 0;
8855 dgst_pos1 = 1;
8856 dgst_pos2 = 2;
8857 dgst_pos3 = 3;
8858 break;
8859
8860 case 8000: hash_type = HASH_TYPE_SHA256;
8861 salt_type = SALT_TYPE_EMBEDDED;
8862 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8863 opts_type = OPTS_TYPE_PT_GENERATE_BE
8864 | OPTS_TYPE_PT_UNICODE
8865 | OPTS_TYPE_ST_ADD80
8866 | OPTS_TYPE_ST_HEX;
8867 kern_type = KERN_TYPE_SYBASEASE;
8868 dgst_size = DGST_SIZE_4_8;
8869 parse_func = sybasease_parse_hash;
8870 sort_by_digest = sort_by_digest_4_8;
8871 opti_type = OPTI_TYPE_ZERO_BYTE
8872 | OPTI_TYPE_PRECOMPUTE_INIT
8873 | OPTI_TYPE_EARLY_SKIP
8874 | OPTI_TYPE_NOT_ITERATED
8875 | OPTI_TYPE_RAW_HASH;
8876 dgst_pos0 = 3;
8877 dgst_pos1 = 7;
8878 dgst_pos2 = 2;
8879 dgst_pos3 = 6;
8880 break;
8881
8882 case 8100: hash_type = HASH_TYPE_SHA1;
8883 salt_type = SALT_TYPE_EMBEDDED;
8884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8885 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8886 kern_type = KERN_TYPE_NETSCALER;
8887 dgst_size = DGST_SIZE_4_5;
8888 parse_func = netscaler_parse_hash;
8889 sort_by_digest = sort_by_digest_4_5;
8890 opti_type = OPTI_TYPE_ZERO_BYTE
8891 | OPTI_TYPE_PRECOMPUTE_INIT
8892 | OPTI_TYPE_PRECOMPUTE_MERKLE
8893 | OPTI_TYPE_EARLY_SKIP
8894 | OPTI_TYPE_NOT_ITERATED
8895 | OPTI_TYPE_PREPENDED_SALT
8896 | OPTI_TYPE_RAW_HASH;
8897 dgst_pos0 = 3;
8898 dgst_pos1 = 4;
8899 dgst_pos2 = 2;
8900 dgst_pos3 = 1;
8901 break;
8902
8903 case 8200: hash_type = HASH_TYPE_SHA256;
8904 salt_type = SALT_TYPE_EMBEDDED;
8905 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8906 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8907 kern_type = KERN_TYPE_CLOUDKEY;
8908 dgst_size = DGST_SIZE_4_8;
8909 parse_func = cloudkey_parse_hash;
8910 sort_by_digest = sort_by_digest_4_8;
8911 opti_type = OPTI_TYPE_ZERO_BYTE;
8912 dgst_pos0 = 0;
8913 dgst_pos1 = 1;
8914 dgst_pos2 = 2;
8915 dgst_pos3 = 3;
8916 break;
8917
8918 case 8300: hash_type = HASH_TYPE_SHA1;
8919 salt_type = SALT_TYPE_EMBEDDED;
8920 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8921 opts_type = OPTS_TYPE_PT_GENERATE_LE
8922 | OPTS_TYPE_ST_HEX
8923 | OPTS_TYPE_ST_ADD80;
8924 kern_type = KERN_TYPE_NSEC3;
8925 dgst_size = DGST_SIZE_4_5;
8926 parse_func = nsec3_parse_hash;
8927 sort_by_digest = sort_by_digest_4_5;
8928 opti_type = OPTI_TYPE_ZERO_BYTE;
8929 dgst_pos0 = 3;
8930 dgst_pos1 = 4;
8931 dgst_pos2 = 2;
8932 dgst_pos3 = 1;
8933 break;
8934
8935 case 8400: hash_type = HASH_TYPE_SHA1;
8936 salt_type = SALT_TYPE_INTERN;
8937 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8938 opts_type = OPTS_TYPE_PT_GENERATE_BE
8939 | OPTS_TYPE_PT_ADD80
8940 | OPTS_TYPE_PT_ADDBITS15;
8941 kern_type = KERN_TYPE_WBB3;
8942 dgst_size = DGST_SIZE_4_5;
8943 parse_func = wbb3_parse_hash;
8944 sort_by_digest = sort_by_digest_4_5;
8945 opti_type = OPTI_TYPE_ZERO_BYTE
8946 | OPTI_TYPE_PRECOMPUTE_INIT
8947 | OPTI_TYPE_NOT_ITERATED;
8948 dgst_pos0 = 3;
8949 dgst_pos1 = 4;
8950 dgst_pos2 = 2;
8951 dgst_pos3 = 1;
8952 break;
8953
8954 case 8500: hash_type = HASH_TYPE_DESRACF;
8955 salt_type = SALT_TYPE_EMBEDDED;
8956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8957 opts_type = OPTS_TYPE_PT_GENERATE_LE
8958 | OPTS_TYPE_ST_UPPER;
8959 kern_type = KERN_TYPE_RACF;
8960 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8961 parse_func = racf_parse_hash;
8962 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8963 opti_type = OPTI_TYPE_ZERO_BYTE
8964 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8965 dgst_pos0 = 0;
8966 dgst_pos1 = 1;
8967 dgst_pos2 = 2;
8968 dgst_pos3 = 3;
8969 break;
8970
8971 case 8600: hash_type = HASH_TYPE_LOTUS5;
8972 salt_type = SALT_TYPE_NONE;
8973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8974 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8975 kern_type = KERN_TYPE_LOTUS5;
8976 dgst_size = DGST_SIZE_4_4;
8977 parse_func = lotus5_parse_hash;
8978 sort_by_digest = sort_by_digest_4_4;
8979 opti_type = OPTI_TYPE_EARLY_SKIP
8980 | OPTI_TYPE_NOT_ITERATED
8981 | OPTI_TYPE_NOT_SALTED
8982 | OPTI_TYPE_RAW_HASH;
8983 dgst_pos0 = 0;
8984 dgst_pos1 = 1;
8985 dgst_pos2 = 2;
8986 dgst_pos3 = 3;
8987 break;
8988
8989 case 8700: hash_type = HASH_TYPE_LOTUS6;
8990 salt_type = SALT_TYPE_EMBEDDED;
8991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8992 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8993 kern_type = KERN_TYPE_LOTUS6;
8994 dgst_size = DGST_SIZE_4_4;
8995 parse_func = lotus6_parse_hash;
8996 sort_by_digest = sort_by_digest_4_4;
8997 opti_type = OPTI_TYPE_EARLY_SKIP
8998 | OPTI_TYPE_NOT_ITERATED
8999 | OPTI_TYPE_RAW_HASH;
9000 dgst_pos0 = 0;
9001 dgst_pos1 = 1;
9002 dgst_pos2 = 2;
9003 dgst_pos3 = 3;
9004 break;
9005
9006 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9007 salt_type = SALT_TYPE_EMBEDDED;
9008 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9009 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9010 kern_type = KERN_TYPE_ANDROIDFDE;
9011 dgst_size = DGST_SIZE_4_4;
9012 parse_func = androidfde_parse_hash;
9013 sort_by_digest = sort_by_digest_4_4;
9014 opti_type = OPTI_TYPE_ZERO_BYTE;
9015 dgst_pos0 = 0;
9016 dgst_pos1 = 1;
9017 dgst_pos2 = 2;
9018 dgst_pos3 = 3;
9019 break;
9020
9021 case 8900: hash_type = HASH_TYPE_SCRYPT;
9022 salt_type = SALT_TYPE_EMBEDDED;
9023 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9024 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9025 kern_type = KERN_TYPE_SCRYPT;
9026 dgst_size = DGST_SIZE_4_8;
9027 parse_func = scrypt_parse_hash;
9028 sort_by_digest = sort_by_digest_4_8;
9029 opti_type = OPTI_TYPE_ZERO_BYTE;
9030 dgst_pos0 = 0;
9031 dgst_pos1 = 1;
9032 dgst_pos2 = 2;
9033 dgst_pos3 = 3;
9034 break;
9035
9036 case 9000: hash_type = HASH_TYPE_SHA1;
9037 salt_type = SALT_TYPE_EMBEDDED;
9038 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9039 opts_type = OPTS_TYPE_PT_GENERATE_LE
9040 | OPTS_TYPE_ST_GENERATE_LE;
9041 kern_type = KERN_TYPE_PSAFE2;
9042 dgst_size = DGST_SIZE_4_5;
9043 parse_func = psafe2_parse_hash;
9044 sort_by_digest = sort_by_digest_4_5;
9045 opti_type = OPTI_TYPE_ZERO_BYTE;
9046 dgst_pos0 = 0;
9047 dgst_pos1 = 1;
9048 dgst_pos2 = 2;
9049 dgst_pos3 = 3;
9050 break;
9051
9052 case 9100: hash_type = HASH_TYPE_LOTUS8;
9053 salt_type = SALT_TYPE_EMBEDDED;
9054 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9055 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9056 kern_type = KERN_TYPE_LOTUS8;
9057 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9058 parse_func = lotus8_parse_hash;
9059 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9060 opti_type = OPTI_TYPE_ZERO_BYTE;
9061 dgst_pos0 = 0;
9062 dgst_pos1 = 1;
9063 dgst_pos2 = 2;
9064 dgst_pos3 = 3;
9065 break;
9066
9067 case 9200: hash_type = HASH_TYPE_SHA256;
9068 salt_type = SALT_TYPE_EMBEDDED;
9069 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9070 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9071 kern_type = KERN_TYPE_PBKDF2_SHA256;
9072 dgst_size = DGST_SIZE_4_32;
9073 parse_func = cisco8_parse_hash;
9074 sort_by_digest = sort_by_digest_4_32;
9075 opti_type = OPTI_TYPE_ZERO_BYTE;
9076 dgst_pos0 = 0;
9077 dgst_pos1 = 1;
9078 dgst_pos2 = 2;
9079 dgst_pos3 = 3;
9080 break;
9081
9082 case 9300: hash_type = HASH_TYPE_SCRYPT;
9083 salt_type = SALT_TYPE_EMBEDDED;
9084 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9085 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9086 kern_type = KERN_TYPE_SCRYPT;
9087 dgst_size = DGST_SIZE_4_8;
9088 parse_func = cisco9_parse_hash;
9089 sort_by_digest = sort_by_digest_4_8;
9090 opti_type = OPTI_TYPE_ZERO_BYTE;
9091 dgst_pos0 = 0;
9092 dgst_pos1 = 1;
9093 dgst_pos2 = 2;
9094 dgst_pos3 = 3;
9095 break;
9096
9097 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9098 salt_type = SALT_TYPE_EMBEDDED;
9099 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9100 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9101 kern_type = KERN_TYPE_OFFICE2007;
9102 dgst_size = DGST_SIZE_4_4;
9103 parse_func = office2007_parse_hash;
9104 sort_by_digest = sort_by_digest_4_4;
9105 opti_type = OPTI_TYPE_ZERO_BYTE;
9106 dgst_pos0 = 0;
9107 dgst_pos1 = 1;
9108 dgst_pos2 = 2;
9109 dgst_pos3 = 3;
9110 break;
9111
9112 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9113 salt_type = SALT_TYPE_EMBEDDED;
9114 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9115 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9116 kern_type = KERN_TYPE_OFFICE2010;
9117 dgst_size = DGST_SIZE_4_4;
9118 parse_func = office2010_parse_hash;
9119 sort_by_digest = sort_by_digest_4_4;
9120 opti_type = OPTI_TYPE_ZERO_BYTE;
9121 dgst_pos0 = 0;
9122 dgst_pos1 = 1;
9123 dgst_pos2 = 2;
9124 dgst_pos3 = 3;
9125 break;
9126
9127 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9128 salt_type = SALT_TYPE_EMBEDDED;
9129 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9130 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9131 kern_type = KERN_TYPE_OFFICE2013;
9132 dgst_size = DGST_SIZE_4_4;
9133 parse_func = office2013_parse_hash;
9134 sort_by_digest = sort_by_digest_4_4;
9135 opti_type = OPTI_TYPE_ZERO_BYTE;
9136 dgst_pos0 = 0;
9137 dgst_pos1 = 1;
9138 dgst_pos2 = 2;
9139 dgst_pos3 = 3;
9140 break;
9141
9142 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9143 salt_type = SALT_TYPE_EMBEDDED;
9144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9145 opts_type = OPTS_TYPE_PT_GENERATE_LE
9146 | OPTS_TYPE_PT_ADD80
9147 | OPTS_TYPE_PT_UNICODE;
9148 kern_type = KERN_TYPE_OLDOFFICE01;
9149 dgst_size = DGST_SIZE_4_4;
9150 parse_func = oldoffice01_parse_hash;
9151 sort_by_digest = sort_by_digest_4_4;
9152 opti_type = OPTI_TYPE_ZERO_BYTE
9153 | OPTI_TYPE_PRECOMPUTE_INIT
9154 | OPTI_TYPE_NOT_ITERATED;
9155 dgst_pos0 = 0;
9156 dgst_pos1 = 1;
9157 dgst_pos2 = 2;
9158 dgst_pos3 = 3;
9159 break;
9160
9161 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9162 salt_type = SALT_TYPE_EMBEDDED;
9163 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9164 opts_type = OPTS_TYPE_PT_GENERATE_LE
9165 | OPTS_TYPE_PT_ADD80;
9166 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9167 dgst_size = DGST_SIZE_4_4;
9168 parse_func = oldoffice01cm1_parse_hash;
9169 sort_by_digest = sort_by_digest_4_4;
9170 opti_type = OPTI_TYPE_ZERO_BYTE
9171 | OPTI_TYPE_PRECOMPUTE_INIT
9172 | OPTI_TYPE_NOT_ITERATED;
9173 dgst_pos0 = 0;
9174 dgst_pos1 = 1;
9175 dgst_pos2 = 2;
9176 dgst_pos3 = 3;
9177 break;
9178
9179 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9180 salt_type = SALT_TYPE_EMBEDDED;
9181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9182 opts_type = OPTS_TYPE_PT_GENERATE_LE
9183 | OPTS_TYPE_PT_ADD80
9184 | OPTS_TYPE_PT_UNICODE
9185 | OPTS_TYPE_PT_NEVERCRACK;
9186 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9187 dgst_size = DGST_SIZE_4_4;
9188 parse_func = oldoffice01cm2_parse_hash;
9189 sort_by_digest = sort_by_digest_4_4;
9190 opti_type = OPTI_TYPE_ZERO_BYTE
9191 | OPTI_TYPE_PRECOMPUTE_INIT
9192 | OPTI_TYPE_NOT_ITERATED;
9193 dgst_pos0 = 0;
9194 dgst_pos1 = 1;
9195 dgst_pos2 = 2;
9196 dgst_pos3 = 3;
9197 break;
9198
9199 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9200 salt_type = SALT_TYPE_EMBEDDED;
9201 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9202 opts_type = OPTS_TYPE_PT_GENERATE_BE
9203 | OPTS_TYPE_PT_ADD80
9204 | OPTS_TYPE_PT_UNICODE;
9205 kern_type = KERN_TYPE_OLDOFFICE34;
9206 dgst_size = DGST_SIZE_4_4;
9207 parse_func = oldoffice34_parse_hash;
9208 sort_by_digest = sort_by_digest_4_4;
9209 opti_type = OPTI_TYPE_ZERO_BYTE
9210 | OPTI_TYPE_PRECOMPUTE_INIT
9211 | OPTI_TYPE_NOT_ITERATED;
9212 dgst_pos0 = 0;
9213 dgst_pos1 = 1;
9214 dgst_pos2 = 2;
9215 dgst_pos3 = 3;
9216 break;
9217
9218 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9219 salt_type = SALT_TYPE_EMBEDDED;
9220 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9221 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9222 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9223 dgst_size = DGST_SIZE_4_4;
9224 parse_func = oldoffice34cm1_parse_hash;
9225 sort_by_digest = sort_by_digest_4_4;
9226 opti_type = OPTI_TYPE_ZERO_BYTE
9227 | OPTI_TYPE_PRECOMPUTE_INIT
9228 | OPTI_TYPE_NOT_ITERATED;
9229 dgst_pos0 = 0;
9230 dgst_pos1 = 1;
9231 dgst_pos2 = 2;
9232 dgst_pos3 = 3;
9233 break;
9234
9235 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9236 salt_type = SALT_TYPE_EMBEDDED;
9237 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9238 opts_type = OPTS_TYPE_PT_GENERATE_BE
9239 | OPTS_TYPE_PT_ADD80
9240 | OPTS_TYPE_PT_UNICODE
9241 | OPTS_TYPE_PT_NEVERCRACK;
9242 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9243 dgst_size = DGST_SIZE_4_4;
9244 parse_func = oldoffice34cm2_parse_hash;
9245 sort_by_digest = sort_by_digest_4_4;
9246 opti_type = OPTI_TYPE_ZERO_BYTE
9247 | OPTI_TYPE_PRECOMPUTE_INIT
9248 | OPTI_TYPE_NOT_ITERATED;
9249 dgst_pos0 = 0;
9250 dgst_pos1 = 1;
9251 dgst_pos2 = 2;
9252 dgst_pos3 = 3;
9253 break;
9254
9255 case 9900: hash_type = HASH_TYPE_MD5;
9256 salt_type = SALT_TYPE_NONE;
9257 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9258 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9259 kern_type = KERN_TYPE_RADMIN2;
9260 dgst_size = DGST_SIZE_4_4;
9261 parse_func = radmin2_parse_hash;
9262 sort_by_digest = sort_by_digest_4_4;
9263 opti_type = OPTI_TYPE_ZERO_BYTE
9264 | OPTI_TYPE_PRECOMPUTE_INIT
9265 | OPTI_TYPE_EARLY_SKIP
9266 | OPTI_TYPE_NOT_ITERATED
9267 | OPTI_TYPE_NOT_SALTED;
9268 dgst_pos0 = 0;
9269 dgst_pos1 = 3;
9270 dgst_pos2 = 2;
9271 dgst_pos3 = 1;
9272 break;
9273
9274 case 10000: hash_type = HASH_TYPE_SHA256;
9275 salt_type = SALT_TYPE_EMBEDDED;
9276 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9277 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9278 kern_type = KERN_TYPE_PBKDF2_SHA256;
9279 dgst_size = DGST_SIZE_4_32;
9280 parse_func = djangopbkdf2_parse_hash;
9281 sort_by_digest = sort_by_digest_4_32;
9282 opti_type = OPTI_TYPE_ZERO_BYTE;
9283 dgst_pos0 = 0;
9284 dgst_pos1 = 1;
9285 dgst_pos2 = 2;
9286 dgst_pos3 = 3;
9287 break;
9288
9289 case 10100: hash_type = HASH_TYPE_SIPHASH;
9290 salt_type = SALT_TYPE_EMBEDDED;
9291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9292 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9293 kern_type = KERN_TYPE_SIPHASH;
9294 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9295 parse_func = siphash_parse_hash;
9296 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9297 opti_type = OPTI_TYPE_ZERO_BYTE
9298 | OPTI_TYPE_NOT_ITERATED
9299 | OPTI_TYPE_RAW_HASH;
9300 dgst_pos0 = 0;
9301 dgst_pos1 = 1;
9302 dgst_pos2 = 2;
9303 dgst_pos3 = 3;
9304 break;
9305
9306 case 10200: hash_type = HASH_TYPE_MD5;
9307 salt_type = SALT_TYPE_EMBEDDED;
9308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9309 opts_type = OPTS_TYPE_PT_GENERATE_LE
9310 | OPTS_TYPE_ST_ADD80
9311 | OPTS_TYPE_ST_ADDBITS14;
9312 kern_type = KERN_TYPE_HMACMD5_PW;
9313 dgst_size = DGST_SIZE_4_4;
9314 parse_func = crammd5_parse_hash;
9315 sort_by_digest = sort_by_digest_4_4;
9316 opti_type = OPTI_TYPE_ZERO_BYTE
9317 | OPTI_TYPE_NOT_ITERATED;
9318 dgst_pos0 = 0;
9319 dgst_pos1 = 3;
9320 dgst_pos2 = 2;
9321 dgst_pos3 = 1;
9322 break;
9323
9324 case 10300: hash_type = HASH_TYPE_SHA1;
9325 salt_type = SALT_TYPE_EMBEDDED;
9326 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9327 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9328 kern_type = KERN_TYPE_SAPH_SHA1;
9329 dgst_size = DGST_SIZE_4_5;
9330 parse_func = saph_sha1_parse_hash;
9331 sort_by_digest = sort_by_digest_4_5;
9332 opti_type = OPTI_TYPE_ZERO_BYTE;
9333 dgst_pos0 = 0;
9334 dgst_pos1 = 1;
9335 dgst_pos2 = 2;
9336 dgst_pos3 = 3;
9337 break;
9338
9339 case 10400: hash_type = HASH_TYPE_PDFU16;
9340 salt_type = SALT_TYPE_EMBEDDED;
9341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9342 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9343 kern_type = KERN_TYPE_PDF11;
9344 dgst_size = DGST_SIZE_4_4;
9345 parse_func = pdf11_parse_hash;
9346 sort_by_digest = sort_by_digest_4_4;
9347 opti_type = OPTI_TYPE_ZERO_BYTE
9348 | OPTI_TYPE_NOT_ITERATED;
9349 dgst_pos0 = 0;
9350 dgst_pos1 = 1;
9351 dgst_pos2 = 2;
9352 dgst_pos3 = 3;
9353 break;
9354
9355 case 10410: hash_type = HASH_TYPE_PDFU16;
9356 salt_type = SALT_TYPE_EMBEDDED;
9357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9358 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9359 kern_type = KERN_TYPE_PDF11CM1;
9360 dgst_size = DGST_SIZE_4_4;
9361 parse_func = pdf11cm1_parse_hash;
9362 sort_by_digest = sort_by_digest_4_4;
9363 opti_type = OPTI_TYPE_ZERO_BYTE
9364 | OPTI_TYPE_NOT_ITERATED;
9365 dgst_pos0 = 0;
9366 dgst_pos1 = 1;
9367 dgst_pos2 = 2;
9368 dgst_pos3 = 3;
9369 break;
9370
9371 case 10420: hash_type = HASH_TYPE_PDFU16;
9372 salt_type = SALT_TYPE_EMBEDDED;
9373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9374 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9375 kern_type = KERN_TYPE_PDF11CM2;
9376 dgst_size = DGST_SIZE_4_4;
9377 parse_func = pdf11cm2_parse_hash;
9378 sort_by_digest = sort_by_digest_4_4;
9379 opti_type = OPTI_TYPE_ZERO_BYTE
9380 | OPTI_TYPE_NOT_ITERATED;
9381 dgst_pos0 = 0;
9382 dgst_pos1 = 1;
9383 dgst_pos2 = 2;
9384 dgst_pos3 = 3;
9385 break;
9386
9387 case 10500: hash_type = HASH_TYPE_PDFU16;
9388 salt_type = SALT_TYPE_EMBEDDED;
9389 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9390 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9391 kern_type = KERN_TYPE_PDF14;
9392 dgst_size = DGST_SIZE_4_4;
9393 parse_func = pdf14_parse_hash;
9394 sort_by_digest = sort_by_digest_4_4;
9395 opti_type = OPTI_TYPE_ZERO_BYTE
9396 | OPTI_TYPE_NOT_ITERATED;
9397 dgst_pos0 = 0;
9398 dgst_pos1 = 1;
9399 dgst_pos2 = 2;
9400 dgst_pos3 = 3;
9401 break;
9402
9403 case 10600: hash_type = HASH_TYPE_SHA256;
9404 salt_type = SALT_TYPE_EMBEDDED;
9405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9406 opts_type = OPTS_TYPE_PT_GENERATE_BE
9407 | OPTS_TYPE_ST_ADD80
9408 | OPTS_TYPE_ST_ADDBITS15
9409 | OPTS_TYPE_HASH_COPY;
9410 kern_type = KERN_TYPE_SHA256_PWSLT;
9411 dgst_size = DGST_SIZE_4_8;
9412 parse_func = pdf17l3_parse_hash;
9413 sort_by_digest = sort_by_digest_4_8;
9414 opti_type = OPTI_TYPE_ZERO_BYTE
9415 | OPTI_TYPE_PRECOMPUTE_INIT
9416 | OPTI_TYPE_PRECOMPUTE_MERKLE
9417 | OPTI_TYPE_EARLY_SKIP
9418 | OPTI_TYPE_NOT_ITERATED
9419 | OPTI_TYPE_APPENDED_SALT
9420 | OPTI_TYPE_RAW_HASH;
9421 dgst_pos0 = 3;
9422 dgst_pos1 = 7;
9423 dgst_pos2 = 2;
9424 dgst_pos3 = 6;
9425 break;
9426
9427 case 10700: hash_type = HASH_TYPE_PDFU32;
9428 salt_type = SALT_TYPE_EMBEDDED;
9429 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9430 opts_type = OPTS_TYPE_PT_GENERATE_LE
9431 | OPTS_TYPE_HASH_COPY;
9432 kern_type = KERN_TYPE_PDF17L8;
9433 dgst_size = DGST_SIZE_4_8;
9434 parse_func = pdf17l8_parse_hash;
9435 sort_by_digest = sort_by_digest_4_8;
9436 opti_type = OPTI_TYPE_ZERO_BYTE
9437 | OPTI_TYPE_NOT_ITERATED;
9438 dgst_pos0 = 0;
9439 dgst_pos1 = 1;
9440 dgst_pos2 = 2;
9441 dgst_pos3 = 3;
9442 break;
9443
9444 case 10800: hash_type = HASH_TYPE_SHA384;
9445 salt_type = SALT_TYPE_NONE;
9446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9447 opts_type = OPTS_TYPE_PT_GENERATE_BE
9448 | OPTS_TYPE_PT_ADD80
9449 | OPTS_TYPE_PT_ADDBITS15;
9450 kern_type = KERN_TYPE_SHA384;
9451 dgst_size = DGST_SIZE_8_8;
9452 parse_func = sha384_parse_hash;
9453 sort_by_digest = sort_by_digest_8_8;
9454 opti_type = OPTI_TYPE_ZERO_BYTE
9455 | OPTI_TYPE_PRECOMPUTE_INIT
9456 | OPTI_TYPE_PRECOMPUTE_MERKLE
9457 | OPTI_TYPE_EARLY_SKIP
9458 | OPTI_TYPE_NOT_ITERATED
9459 | OPTI_TYPE_NOT_SALTED
9460 | OPTI_TYPE_RAW_HASH;
9461 dgst_pos0 = 6;
9462 dgst_pos1 = 7;
9463 dgst_pos2 = 4;
9464 dgst_pos3 = 5;
9465 break;
9466
9467 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9468 salt_type = SALT_TYPE_EMBEDDED;
9469 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9470 opts_type = OPTS_TYPE_PT_GENERATE_LE
9471 | OPTS_TYPE_ST_BASE64
9472 | OPTS_TYPE_HASH_COPY;
9473 kern_type = KERN_TYPE_PBKDF2_SHA256;
9474 dgst_size = DGST_SIZE_4_32;
9475 parse_func = pbkdf2_sha256_parse_hash;
9476 sort_by_digest = sort_by_digest_4_32;
9477 opti_type = OPTI_TYPE_ZERO_BYTE;
9478 dgst_pos0 = 0;
9479 dgst_pos1 = 1;
9480 dgst_pos2 = 2;
9481 dgst_pos3 = 3;
9482 break;
9483
9484 case 11000: hash_type = HASH_TYPE_MD5;
9485 salt_type = SALT_TYPE_INTERN;
9486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9487 opts_type = OPTS_TYPE_PT_GENERATE_LE
9488 | OPTS_TYPE_PT_ADD80;
9489 kern_type = KERN_TYPE_PRESTASHOP;
9490 dgst_size = DGST_SIZE_4_4;
9491 parse_func = prestashop_parse_hash;
9492 sort_by_digest = sort_by_digest_4_4;
9493 opti_type = OPTI_TYPE_ZERO_BYTE
9494 | OPTI_TYPE_PRECOMPUTE_INIT
9495 | OPTI_TYPE_NOT_ITERATED
9496 | OPTI_TYPE_PREPENDED_SALT;
9497 dgst_pos0 = 0;
9498 dgst_pos1 = 3;
9499 dgst_pos2 = 2;
9500 dgst_pos3 = 1;
9501 break;
9502
9503 case 11100: hash_type = HASH_TYPE_MD5;
9504 salt_type = SALT_TYPE_EMBEDDED;
9505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9506 opts_type = OPTS_TYPE_PT_GENERATE_LE
9507 | OPTS_TYPE_ST_ADD80;
9508 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9509 dgst_size = DGST_SIZE_4_4;
9510 parse_func = postgresql_auth_parse_hash;
9511 sort_by_digest = sort_by_digest_4_4;
9512 opti_type = OPTI_TYPE_ZERO_BYTE
9513 | OPTI_TYPE_PRECOMPUTE_INIT
9514 | OPTI_TYPE_PRECOMPUTE_MERKLE
9515 | OPTI_TYPE_EARLY_SKIP;
9516 dgst_pos0 = 0;
9517 dgst_pos1 = 3;
9518 dgst_pos2 = 2;
9519 dgst_pos3 = 1;
9520 break;
9521
9522 case 11200: hash_type = HASH_TYPE_SHA1;
9523 salt_type = SALT_TYPE_EMBEDDED;
9524 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9525 opts_type = OPTS_TYPE_PT_GENERATE_BE
9526 | OPTS_TYPE_PT_ADD80
9527 | OPTS_TYPE_ST_HEX;
9528 kern_type = KERN_TYPE_MYSQL_AUTH;
9529 dgst_size = DGST_SIZE_4_5;
9530 parse_func = mysql_auth_parse_hash;
9531 sort_by_digest = sort_by_digest_4_5;
9532 opti_type = OPTI_TYPE_ZERO_BYTE
9533 | OPTI_TYPE_EARLY_SKIP;
9534 dgst_pos0 = 3;
9535 dgst_pos1 = 4;
9536 dgst_pos2 = 2;
9537 dgst_pos3 = 1;
9538 break;
9539
9540 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9541 salt_type = SALT_TYPE_EMBEDDED;
9542 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9543 opts_type = OPTS_TYPE_PT_GENERATE_LE
9544 | OPTS_TYPE_ST_HEX
9545 | OPTS_TYPE_ST_ADD80;
9546 kern_type = KERN_TYPE_BITCOIN_WALLET;
9547 dgst_size = DGST_SIZE_4_4;
9548 parse_func = bitcoin_wallet_parse_hash;
9549 sort_by_digest = sort_by_digest_4_4;
9550 opti_type = OPTI_TYPE_ZERO_BYTE;
9551 dgst_pos0 = 0;
9552 dgst_pos1 = 1;
9553 dgst_pos2 = 2;
9554 dgst_pos3 = 3;
9555 break;
9556
9557 case 11400: hash_type = HASH_TYPE_MD5;
9558 salt_type = SALT_TYPE_EMBEDDED;
9559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9560 opts_type = OPTS_TYPE_PT_GENERATE_LE
9561 | OPTS_TYPE_PT_ADD80
9562 | OPTS_TYPE_HASH_COPY;
9563 kern_type = KERN_TYPE_SIP_AUTH;
9564 dgst_size = DGST_SIZE_4_4;
9565 parse_func = sip_auth_parse_hash;
9566 sort_by_digest = sort_by_digest_4_4;
9567 opti_type = OPTI_TYPE_ZERO_BYTE;
9568 dgst_pos0 = 0;
9569 dgst_pos1 = 3;
9570 dgst_pos2 = 2;
9571 dgst_pos3 = 1;
9572 break;
9573
9574 case 11500: hash_type = HASH_TYPE_CRC32;
9575 salt_type = SALT_TYPE_INTERN;
9576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9577 opts_type = OPTS_TYPE_PT_GENERATE_LE
9578 | OPTS_TYPE_ST_GENERATE_LE
9579 | OPTS_TYPE_ST_HEX;
9580 kern_type = KERN_TYPE_CRC32;
9581 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9582 parse_func = crc32_parse_hash;
9583 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9584 opti_type = OPTI_TYPE_ZERO_BYTE;
9585 dgst_pos0 = 0;
9586 dgst_pos1 = 1;
9587 dgst_pos2 = 2;
9588 dgst_pos3 = 3;
9589 break;
9590
9591 case 11600: hash_type = HASH_TYPE_AES;
9592 salt_type = SALT_TYPE_EMBEDDED;
9593 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9594 opts_type = OPTS_TYPE_PT_GENERATE_LE
9595 | OPTS_TYPE_PT_NEVERCRACK;
9596 kern_type = KERN_TYPE_SEVEN_ZIP;
9597 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9598 parse_func = seven_zip_parse_hash;
9599 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9600 opti_type = OPTI_TYPE_ZERO_BYTE;
9601 dgst_pos0 = 0;
9602 dgst_pos1 = 1;
9603 dgst_pos2 = 2;
9604 dgst_pos3 = 3;
9605 break;
9606
9607 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9608 salt_type = SALT_TYPE_NONE;
9609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9610 opts_type = OPTS_TYPE_PT_GENERATE_LE
9611 | OPTS_TYPE_PT_ADD01;
9612 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9613 dgst_size = DGST_SIZE_4_8;
9614 parse_func = gost2012sbog_256_parse_hash;
9615 sort_by_digest = sort_by_digest_4_8;
9616 opti_type = OPTI_TYPE_ZERO_BYTE;
9617 dgst_pos0 = 0;
9618 dgst_pos1 = 1;
9619 dgst_pos2 = 2;
9620 dgst_pos3 = 3;
9621 break;
9622
9623 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9624 salt_type = SALT_TYPE_NONE;
9625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9626 opts_type = OPTS_TYPE_PT_GENERATE_LE
9627 | OPTS_TYPE_PT_ADD01;
9628 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9629 dgst_size = DGST_SIZE_4_16;
9630 parse_func = gost2012sbog_512_parse_hash;
9631 sort_by_digest = sort_by_digest_4_16;
9632 opti_type = OPTI_TYPE_ZERO_BYTE;
9633 dgst_pos0 = 0;
9634 dgst_pos1 = 1;
9635 dgst_pos2 = 2;
9636 dgst_pos3 = 3;
9637 break;
9638
9639 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9640 salt_type = SALT_TYPE_EMBEDDED;
9641 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9642 opts_type = OPTS_TYPE_PT_GENERATE_LE
9643 | OPTS_TYPE_ST_BASE64
9644 | OPTS_TYPE_HASH_COPY;
9645 kern_type = KERN_TYPE_PBKDF2_MD5;
9646 dgst_size = DGST_SIZE_4_32;
9647 parse_func = pbkdf2_md5_parse_hash;
9648 sort_by_digest = sort_by_digest_4_32;
9649 opti_type = OPTI_TYPE_ZERO_BYTE;
9650 dgst_pos0 = 0;
9651 dgst_pos1 = 1;
9652 dgst_pos2 = 2;
9653 dgst_pos3 = 3;
9654 break;
9655
9656 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9657 salt_type = SALT_TYPE_EMBEDDED;
9658 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9659 opts_type = OPTS_TYPE_PT_GENERATE_LE
9660 | OPTS_TYPE_ST_BASE64
9661 | OPTS_TYPE_HASH_COPY;
9662 kern_type = KERN_TYPE_PBKDF2_SHA1;
9663 dgst_size = DGST_SIZE_4_32;
9664 parse_func = pbkdf2_sha1_parse_hash;
9665 sort_by_digest = sort_by_digest_4_32;
9666 opti_type = OPTI_TYPE_ZERO_BYTE;
9667 dgst_pos0 = 0;
9668 dgst_pos1 = 1;
9669 dgst_pos2 = 2;
9670 dgst_pos3 = 3;
9671 break;
9672
9673 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9674 salt_type = SALT_TYPE_EMBEDDED;
9675 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9676 opts_type = OPTS_TYPE_PT_GENERATE_LE
9677 | OPTS_TYPE_ST_BASE64
9678 | OPTS_TYPE_HASH_COPY;
9679 kern_type = KERN_TYPE_PBKDF2_SHA512;
9680 dgst_size = DGST_SIZE_8_16;
9681 parse_func = pbkdf2_sha512_parse_hash;
9682 sort_by_digest = sort_by_digest_8_16;
9683 opti_type = OPTI_TYPE_ZERO_BYTE;
9684 dgst_pos0 = 0;
9685 dgst_pos1 = 1;
9686 dgst_pos2 = 2;
9687 dgst_pos3 = 3;
9688 break;
9689
9690 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9691 salt_type = SALT_TYPE_EMBEDDED;
9692 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9693 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9694 kern_type = KERN_TYPE_ECRYPTFS;
9695 dgst_size = DGST_SIZE_8_8;
9696 parse_func = ecryptfs_parse_hash;
9697 sort_by_digest = sort_by_digest_8_8;
9698 opti_type = OPTI_TYPE_ZERO_BYTE;
9699 dgst_pos0 = 0;
9700 dgst_pos1 = 1;
9701 dgst_pos2 = 2;
9702 dgst_pos3 = 3;
9703 break;
9704
9705 case 12300: hash_type = HASH_TYPE_ORACLET;
9706 salt_type = SALT_TYPE_EMBEDDED;
9707 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9708 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9709 kern_type = KERN_TYPE_ORACLET;
9710 dgst_size = DGST_SIZE_8_16;
9711 parse_func = oraclet_parse_hash;
9712 sort_by_digest = sort_by_digest_8_16;
9713 opti_type = OPTI_TYPE_ZERO_BYTE;
9714 dgst_pos0 = 0;
9715 dgst_pos1 = 1;
9716 dgst_pos2 = 2;
9717 dgst_pos3 = 3;
9718 break;
9719
9720 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9721 salt_type = SALT_TYPE_EMBEDDED;
9722 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9723 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9724 kern_type = KERN_TYPE_BSDICRYPT;
9725 dgst_size = DGST_SIZE_4_4;
9726 parse_func = bsdicrypt_parse_hash;
9727 sort_by_digest = sort_by_digest_4_4;
9728 opti_type = OPTI_TYPE_ZERO_BYTE
9729 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9730 dgst_pos0 = 0;
9731 dgst_pos1 = 1;
9732 dgst_pos2 = 2;
9733 dgst_pos3 = 3;
9734 break;
9735
9736 case 12500: hash_type = HASH_TYPE_RAR3HP;
9737 salt_type = SALT_TYPE_EMBEDDED;
9738 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9739 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9740 kern_type = KERN_TYPE_RAR3;
9741 dgst_size = DGST_SIZE_4_4;
9742 parse_func = rar3hp_parse_hash;
9743 sort_by_digest = sort_by_digest_4_4;
9744 opti_type = OPTI_TYPE_ZERO_BYTE;
9745 dgst_pos0 = 0;
9746 dgst_pos1 = 1;
9747 dgst_pos2 = 2;
9748 dgst_pos3 = 3;
9749 break;
9750
9751 case 12600: hash_type = HASH_TYPE_SHA256;
9752 salt_type = SALT_TYPE_INTERN;
9753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9754 opts_type = OPTS_TYPE_PT_GENERATE_BE
9755 | OPTS_TYPE_PT_ADD80;
9756 kern_type = KERN_TYPE_CF10;
9757 dgst_size = DGST_SIZE_4_8;
9758 parse_func = cf10_parse_hash;
9759 sort_by_digest = sort_by_digest_4_8;
9760 opti_type = OPTI_TYPE_ZERO_BYTE
9761 | OPTI_TYPE_PRECOMPUTE_INIT
9762 | OPTI_TYPE_EARLY_SKIP
9763 | OPTI_TYPE_NOT_ITERATED;
9764 dgst_pos0 = 3;
9765 dgst_pos1 = 7;
9766 dgst_pos2 = 2;
9767 dgst_pos3 = 6;
9768 break;
9769
9770 case 12700: hash_type = HASH_TYPE_AES;
9771 salt_type = SALT_TYPE_EMBEDDED;
9772 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9773 opts_type = OPTS_TYPE_PT_GENERATE_LE
9774 | OPTS_TYPE_HASH_COPY;
9775 kern_type = KERN_TYPE_MYWALLET;
9776 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9777 parse_func = mywallet_parse_hash;
9778 sort_by_digest = sort_by_digest_4_5;
9779 opti_type = OPTI_TYPE_ZERO_BYTE;
9780 dgst_pos0 = 0;
9781 dgst_pos1 = 1;
9782 dgst_pos2 = 2;
9783 dgst_pos3 = 3;
9784 break;
9785
9786 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9787 salt_type = SALT_TYPE_EMBEDDED;
9788 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9789 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9790 kern_type = KERN_TYPE_MS_DRSR;
9791 dgst_size = DGST_SIZE_4_8;
9792 parse_func = ms_drsr_parse_hash;
9793 sort_by_digest = sort_by_digest_4_8;
9794 opti_type = OPTI_TYPE_ZERO_BYTE;
9795 dgst_pos0 = 0;
9796 dgst_pos1 = 1;
9797 dgst_pos2 = 2;
9798 dgst_pos3 = 3;
9799 break;
9800
9801 default: usage_mini_print (PROGNAME); return (-1);
9802 }
9803
9804 /**
9805 * transpose
9806 */
9807
9808 data.parse_func = parse_func;
9809
9810 /**
9811 * misc stuff
9812 */
9813
9814 if (hex_salt)
9815 {
9816 if (salt_type == SALT_TYPE_INTERN)
9817 {
9818 opts_type |= OPTS_TYPE_ST_HEX;
9819 }
9820 else
9821 {
9822 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9823
9824 return (-1);
9825 }
9826 }
9827
9828 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9829 | (salt_type == SALT_TYPE_EXTERN)
9830 | (salt_type == SALT_TYPE_EMBEDDED)
9831 | (salt_type == SALT_TYPE_VIRTUAL));
9832
9833 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9834
9835 data.hash_type = hash_type;
9836 data.attack_mode = attack_mode;
9837 data.attack_kern = attack_kern;
9838 data.attack_exec = attack_exec;
9839 data.kern_type = kern_type;
9840 data.opts_type = opts_type;
9841 data.dgst_size = dgst_size;
9842 data.salt_type = salt_type;
9843 data.isSalted = isSalted;
9844 data.sort_by_digest = sort_by_digest;
9845 data.dgst_pos0 = dgst_pos0;
9846 data.dgst_pos1 = dgst_pos1;
9847 data.dgst_pos2 = dgst_pos2;
9848 data.dgst_pos3 = dgst_pos3;
9849
9850 esalt_size = 0;
9851
9852 switch (hash_mode)
9853 {
9854 case 2500: esalt_size = sizeof (wpa_t); break;
9855 case 5300: esalt_size = sizeof (ikepsk_t); break;
9856 case 5400: esalt_size = sizeof (ikepsk_t); break;
9857 case 5500: esalt_size = sizeof (netntlm_t); break;
9858 case 5600: esalt_size = sizeof (netntlm_t); break;
9859 case 6211:
9860 case 6212:
9861 case 6213:
9862 case 6221:
9863 case 6222:
9864 case 6223:
9865 case 6231:
9866 case 6232:
9867 case 6233:
9868 case 6241:
9869 case 6242:
9870 case 6243: esalt_size = sizeof (tc_t); break;
9871 case 6600: esalt_size = sizeof (agilekey_t); break;
9872 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9873 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9874 case 7300: esalt_size = sizeof (rakp_t); break;
9875 case 7500: esalt_size = sizeof (krb5pa_t); break;
9876 case 8200: esalt_size = sizeof (cloudkey_t); break;
9877 case 8800: esalt_size = sizeof (androidfde_t); break;
9878 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9879 case 9400: esalt_size = sizeof (office2007_t); break;
9880 case 9500: esalt_size = sizeof (office2010_t); break;
9881 case 9600: esalt_size = sizeof (office2013_t); break;
9882 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9883 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9884 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9885 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9886 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9887 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9888 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9889 case 10200: esalt_size = sizeof (cram_md5_t); break;
9890 case 10400: esalt_size = sizeof (pdf_t); break;
9891 case 10410: esalt_size = sizeof (pdf_t); break;
9892 case 10420: esalt_size = sizeof (pdf_t); break;
9893 case 10500: esalt_size = sizeof (pdf_t); break;
9894 case 10600: esalt_size = sizeof (pdf_t); break;
9895 case 10700: esalt_size = sizeof (pdf_t); break;
9896 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9897 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9898 case 11400: esalt_size = sizeof (sip_t); break;
9899 case 11600: esalt_size = sizeof (seven_zip_t); break;
9900 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9901 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9902 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9903 }
9904
9905 data.esalt_size = esalt_size;
9906
9907 /**
9908 * choose dictionary parser
9909 */
9910
9911 if (hash_type == HASH_TYPE_LM)
9912 {
9913 get_next_word_func = get_next_word_lm;
9914 }
9915 else if (opts_type & OPTS_TYPE_PT_UPPER)
9916 {
9917 get_next_word_func = get_next_word_uc;
9918 }
9919 else
9920 {
9921 get_next_word_func = get_next_word_std;
9922 }
9923
9924 /**
9925 * dictstat
9926 */
9927
9928 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
9929
9930 #ifdef _POSIX
9931 size_t dictstat_nmemb = 0;
9932 #endif
9933
9934 #ifdef _WIN
9935 uint dictstat_nmemb = 0;
9936 #endif
9937
9938 char dictstat[256];
9939
9940 FILE *dictstat_fp = NULL;
9941
9942 if (keyspace == 0)
9943 {
9944 memset (dictstat, 0, sizeof (dictstat));
9945
9946 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
9947
9948 dictstat_fp = fopen (dictstat, "rb");
9949
9950 if (dictstat_fp)
9951 {
9952 #ifdef _POSIX
9953 struct stat tmpstat;
9954
9955 fstat (fileno (dictstat_fp), &tmpstat);
9956 #endif
9957
9958 #ifdef _WIN
9959 struct stat64 tmpstat;
9960
9961 _fstat64 (fileno (dictstat_fp), &tmpstat);
9962 #endif
9963
9964 if (tmpstat.st_mtime < COMPTIME)
9965 {
9966 /* with v0.15 the format changed so we have to ensure user is using a good version
9967 since there is no version-header in the dictstat file */
9968
9969 fclose (dictstat_fp);
9970
9971 unlink (dictstat);
9972 }
9973 else
9974 {
9975 while (!feof (dictstat_fp))
9976 {
9977 dictstat_t d;
9978
9979 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
9980
9981 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
9982
9983 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
9984 {
9985 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
9986
9987 return -1;
9988 }
9989 }
9990
9991 fclose (dictstat_fp);
9992 }
9993 }
9994 }
9995
9996 /**
9997 * potfile
9998 */
9999
10000 char potfile[256];
10001
10002 memset (potfile, 0, sizeof (potfile));
10003
10004 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10005
10006 data.pot_fp = NULL;
10007
10008 FILE *out_fp = NULL;
10009 FILE *pot_fp = NULL;
10010
10011 if (show == 1 || left == 1)
10012 {
10013 pot_fp = fopen (potfile, "rb");
10014
10015 if (pot_fp == NULL)
10016 {
10017 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10018
10019 return (-1);
10020 }
10021
10022 if (outfile != NULL)
10023 {
10024 if ((out_fp = fopen (outfile, "ab")) == NULL)
10025 {
10026 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10027
10028 fclose (pot_fp);
10029
10030 return (-1);
10031 }
10032 }
10033 else
10034 {
10035 out_fp = stdout;
10036 }
10037 }
10038 else
10039 {
10040 if (potfile_disable == 0)
10041 {
10042 pot_fp = fopen (potfile, "ab");
10043
10044 if (pot_fp == NULL)
10045 {
10046 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10047
10048 return (-1);
10049 }
10050
10051 data.pot_fp = pot_fp;
10052 }
10053 }
10054
10055 pot_t *pot = NULL;
10056
10057 uint pot_cnt = 0;
10058 uint pot_avail = 0;
10059
10060 if (show == 1 || left == 1)
10061 {
10062 SUPPRESS_OUTPUT = 1;
10063
10064 pot_avail = count_lines (pot_fp);
10065
10066 rewind (pot_fp);
10067
10068 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10069
10070 uint pot_hashes_avail = 0;
10071
10072 uint line_num = 0;
10073
10074 while (!feof (pot_fp))
10075 {
10076 line_num++;
10077
10078 char line_buf[BUFSIZ];
10079
10080 int line_len = fgetl (pot_fp, line_buf);
10081
10082 if (line_len == 0) continue;
10083
10084 char *plain_buf = line_buf + line_len;
10085
10086 pot_t *pot_ptr = &pot[pot_cnt];
10087
10088 hash_t *hashes_buf = &pot_ptr->hash;
10089
10090 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10091 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10092
10093 if (pot_cnt == pot_hashes_avail)
10094 {
10095 uint pos = 0;
10096
10097 for (pos = 0; pos < INCR_POT; pos++)
10098 {
10099 if ((pot_cnt + pos) >= pot_avail) break;
10100
10101 pot_t *tmp_pot = &pot[pot_cnt + pos];
10102
10103 hash_t *tmp_hash = &tmp_pot->hash;
10104
10105 tmp_hash->digest = mymalloc (dgst_size);
10106
10107 if (isSalted)
10108 {
10109 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10110 }
10111
10112 if (esalt_size)
10113 {
10114 tmp_hash->esalt = mymalloc (esalt_size);
10115 }
10116
10117 pot_hashes_avail++;
10118 }
10119 }
10120
10121 int plain_len = 0;
10122
10123 int parser_status;
10124
10125 int iter = MAX_CUT_TRIES;
10126
10127 do
10128 {
10129 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10130 {
10131 if (line_buf[i] == ':')
10132 {
10133 line_len--;
10134
10135 break;
10136 }
10137 }
10138
10139 if (data.hash_mode != 2500)
10140 {
10141 parser_status = parse_func (line_buf, line_len, hashes_buf);
10142 }
10143 else
10144 {
10145 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10146
10147 if (line_len > max_salt_size)
10148 {
10149 parser_status = PARSER_GLOBAL_LENGTH;
10150 }
10151 else
10152 {
10153 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10154
10155 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10156
10157 hashes_buf->salt->salt_len = line_len;
10158
10159 parser_status = PARSER_OK;
10160 }
10161 }
10162
10163 // if NOT parsed without error, we add the ":" to the plain
10164
10165 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10166 {
10167 plain_len++;
10168 plain_buf--;
10169 }
10170
10171 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10172
10173 if (parser_status < PARSER_GLOBAL_ZERO)
10174 {
10175 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10176
10177 continue;
10178 }
10179
10180 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10181
10182 pot_ptr->plain_len = plain_len;
10183
10184 pot_cnt++;
10185 }
10186
10187 fclose (pot_fp);
10188
10189 SUPPRESS_OUTPUT = 0;
10190
10191 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10192 }
10193
10194 /**
10195 * kernel accel and loops auto adjustment
10196 */
10197
10198 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10199 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10200
10201 if (workload_profile == 1)
10202 {
10203 kernel_loops /= 8;
10204 kernel_accel /= 4;
10205
10206 if (kernel_loops == 0) kernel_loops = 8;
10207 if (kernel_accel == 0) kernel_accel = 2;
10208 }
10209 else if (workload_profile == 3)
10210 {
10211 kernel_loops *= 8;
10212 kernel_accel *= 4;
10213
10214 if (kernel_loops > 1024) kernel_loops = 1024;
10215 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10216 }
10217
10218 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10219
10220 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10221 {
10222 kernel_loops = 1024;
10223 }
10224
10225 if (hash_mode == 12500)
10226 {
10227 kernel_loops = ROUNDS_RAR3 / 16;
10228 }
10229
10230 data.kernel_accel = kernel_accel;
10231 data.kernel_loops = kernel_loops;
10232
10233 /**
10234 * word len
10235 */
10236
10237 uint pw_min = PW_MIN;
10238 uint pw_max = PW_MAX;
10239
10240 switch (hash_mode)
10241 {
10242 case 400: if (pw_max > 40) pw_max = 40;
10243 break;
10244 case 500: if (pw_max > 16) pw_max = 16;
10245 break;
10246 case 1500: if (pw_max > 8) pw_max = 8;
10247 break;
10248 case 1600: if (pw_max > 16) pw_max = 16;
10249 break;
10250 case 1800: if (pw_max > 16) pw_max = 16;
10251 break;
10252 case 2100: if (pw_max > 16) pw_max = 16;
10253 break;
10254 case 2500: if (pw_min < 8) pw_min = 8;
10255 break;
10256 case 3000: if (pw_max > 7) pw_max = 7;
10257 break;
10258 case 5200: if (pw_max > 24) pw_max = 24;
10259 break;
10260 case 5800: if (pw_max > 16) pw_max = 16;
10261 break;
10262 case 6300: if (pw_max > 16) pw_max = 16;
10263 break;
10264 case 7400: if (pw_max > 16) pw_max = 16;
10265 break;
10266 case 7900: if (pw_max > 48) pw_max = 48;
10267 break;
10268 case 8500: if (pw_max > 8) pw_max = 8;
10269 break;
10270 case 8600: if (pw_max > 16) pw_max = 16;
10271 break;
10272 case 9710: pw_min = 5;
10273 pw_max = 5;
10274 break;
10275 case 9810: pw_min = 5;
10276 pw_max = 5;
10277 break;
10278 case 10410: pw_min = 5;
10279 pw_max = 5;
10280 break;
10281 case 10300: if (pw_max < 3) pw_min = 3;
10282 if (pw_max > 40) pw_max = 40;
10283 break;
10284 case 10500: if (pw_max < 3) pw_min = 3;
10285 if (pw_max > 40) pw_max = 40;
10286 break;
10287 case 10700: if (pw_max > 16) pw_max = 16;
10288 break;
10289 case 11300: if (pw_max > 40) pw_max = 40;
10290 break;
10291 case 12500: if (pw_max > 20) pw_max = 20;
10292 break;
10293 case 12800: if (pw_max > 24) pw_max = 24;
10294 break;
10295 }
10296
10297 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10298 {
10299 switch (attack_kern)
10300 {
10301 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10302 break;
10303 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10304 break;
10305 }
10306 }
10307
10308 /**
10309 * charsets : keep them together for more easy maintainnce
10310 */
10311
10312 cs_t mp_sys[6];
10313 cs_t mp_usr[4];
10314
10315 memset (mp_sys, 0, sizeof (mp_sys));
10316 memset (mp_usr, 0, sizeof (mp_usr));
10317
10318 mp_setup_sys (mp_sys);
10319
10320 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10321 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10322 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10323 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10324
10325 /**
10326 * load hashes, part I: find input mode, count hashes
10327 */
10328
10329 uint hashlist_mode = 0;
10330 uint hashlist_format = HLFMT_HASHCAT;
10331
10332 uint hashes_avail = 0;
10333
10334 if (benchmark == 0)
10335 {
10336 struct stat f;
10337
10338 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10339
10340 if ((hash_mode == 2500) ||
10341 (hash_mode == 5200) ||
10342 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10343 (hash_mode == 9000))
10344 {
10345 hashlist_mode = HL_MODE_ARG;
10346
10347 char *hashfile = myargv[optind];
10348
10349 data.hashfile = hashfile;
10350
10351 logfile_top_var_string ("target", hashfile);
10352 }
10353
10354 if (hashlist_mode == HL_MODE_ARG)
10355 {
10356 if (hash_mode == 2500)
10357 {
10358 struct stat st;
10359
10360 if (stat (data.hashfile, &st) == -1)
10361 {
10362 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10363
10364 return (-1);
10365 }
10366
10367 hashes_avail = st.st_size / sizeof (hccap_t);
10368 }
10369 else
10370 {
10371 hashes_avail = 1;
10372 }
10373 }
10374 else if (hashlist_mode == HL_MODE_FILE)
10375 {
10376 char *hashfile = myargv[optind];
10377
10378 data.hashfile = hashfile;
10379
10380 logfile_top_var_string ("target", hashfile);
10381
10382 FILE *fp = NULL;
10383
10384 if ((fp = fopen (hashfile, "rb")) == NULL)
10385 {
10386 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10387
10388 return (-1);
10389 }
10390
10391 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10392
10393 hashes_avail = count_lines (fp);
10394
10395 rewind (fp);
10396
10397 if (hashes_avail == 0)
10398 {
10399 log_error ("ERROR: hashfile is empty or corrupt");
10400
10401 fclose (fp);
10402
10403 return (-1);
10404 }
10405
10406 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10407
10408 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10409 {
10410 log_error ("ERROR: remove not supported in native hashfile-format mode");
10411
10412 fclose (fp);
10413
10414 return (-1);
10415 }
10416
10417 fclose (fp);
10418 }
10419 }
10420 else
10421 {
10422 hashlist_mode = HL_MODE_ARG;
10423
10424 hashes_avail = 1;
10425 }
10426
10427 if (hash_mode == 3000) hashes_avail *= 2;
10428
10429 data.hashlist_mode = hashlist_mode;
10430 data.hashlist_format = hashlist_format;
10431
10432 logfile_top_uint (hashlist_mode);
10433 logfile_top_uint (hashlist_format);
10434
10435 /**
10436 * load hashes, part II: allocate required memory, set pointers
10437 */
10438
10439 hash_t *hashes_buf = NULL;
10440 void *digests_buf = NULL;
10441 salt_t *salts_buf = NULL;
10442 void *esalts_buf = NULL;
10443
10444 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10445
10446 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10447
10448 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10449 {
10450 uint32_t hash_pos;
10451
10452 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10453 {
10454 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10455
10456 hashes_buf[hash_pos].hash_info = hash_info;
10457
10458 if (username && (remove || show || left))
10459 {
10460 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10461 }
10462
10463 if (benchmark)
10464 {
10465 hash_info->orighash = (char *) mymalloc (256);
10466 }
10467 }
10468 }
10469
10470 if (isSalted)
10471 {
10472 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10473
10474 if (esalt_size)
10475 {
10476 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10477 }
10478 }
10479 else
10480 {
10481 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10482 }
10483
10484 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10485 {
10486 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10487
10488 if (isSalted)
10489 {
10490 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10491
10492 if (esalt_size)
10493 {
10494 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10495 }
10496 }
10497 else
10498 {
10499 hashes_buf[hash_pos].salt = &salts_buf[0];
10500 }
10501 }
10502
10503 /**
10504 * load hashes, part III: parse hashes or generate them if benchmark
10505 */
10506
10507 uint hashes_cnt = 0;
10508
10509 if (benchmark == 0)
10510 {
10511 if (keyspace == 1)
10512 {
10513 // useless to read hash file for keyspace, cheat a little bit w/ optind
10514 }
10515 else if (hashes_avail == 0)
10516 {
10517 }
10518 else if (hashlist_mode == HL_MODE_ARG)
10519 {
10520 char *input_buf = myargv[optind];
10521
10522 uint input_len = strlen (input_buf);
10523
10524 logfile_top_var_string ("target", input_buf);
10525
10526 char *hash_buf = NULL;
10527 int hash_len = 0;
10528
10529 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10530
10531 if (hash_len)
10532 {
10533 if (opts_type & OPTS_TYPE_HASH_COPY)
10534 {
10535 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10536
10537 hash_info_tmp->orighash = mystrdup (hash_buf);
10538 }
10539
10540 if (isSalted)
10541 {
10542 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10543 }
10544
10545 int parser_status = PARSER_OK;
10546
10547 if (hash_mode == 2500)
10548 {
10549 if (hash_len == 0)
10550 {
10551 log_error ("ERROR: hccap file not specified");
10552
10553 return (-1);
10554 }
10555
10556 hashlist_mode = HL_MODE_FILE;
10557
10558 data.hashlist_mode = hashlist_mode;
10559
10560 FILE *fp = fopen (hash_buf, "rb");
10561
10562 if (fp == NULL)
10563 {
10564 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10565
10566 return (-1);
10567 }
10568
10569 if (hashes_avail < 1)
10570 {
10571 log_error ("ERROR: hccap file is empty or corrupt");
10572
10573 fclose (fp);
10574
10575 return (-1);
10576 }
10577
10578 uint hccap_size = sizeof (hccap_t);
10579
10580 char in[hccap_size];
10581
10582 while (!feof (fp))
10583 {
10584 int n = fread (&in, hccap_size, 1, fp);
10585
10586 if (n != 1)
10587 {
10588 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10589
10590 break;
10591 }
10592
10593 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10594
10595 if (parser_status != PARSER_OK)
10596 {
10597 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10598
10599 continue;
10600 }
10601
10602 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10603
10604 if ((show == 1) || (left == 1))
10605 {
10606 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10607
10608 char *salt_ptr = (char *) tmp_salt->salt_buf;
10609
10610 int cur_pos = tmp_salt->salt_len;
10611 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10612
10613 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10614
10615 unsigned char *pke_ptr = (unsigned char *) wpa->pke;
10616
10617 // do the appending task
10618
10619 snprintf (salt_ptr + cur_pos,
10620 rem_len,
10621 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10622 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10623 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10624
10625
10626 // memset () the remaining part of the salt
10627
10628 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10629 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10630
10631 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10632
10633 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10634 }
10635
10636 if (show == 1) handle_show_request (pot, pot_cnt, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf, out_fp);
10637 if (left == 1) handle_left_request (pot, pot_cnt, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf, out_fp);
10638
10639 hashes_cnt++;
10640 }
10641
10642 fclose (fp);
10643 }
10644 else if (hash_mode == 3000)
10645 {
10646 if (hash_len == 32)
10647 {
10648 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10649
10650 hash_t *lm_hash_left = NULL;
10651
10652 if (parser_status == PARSER_OK)
10653 {
10654 lm_hash_left = &hashes_buf[hashes_cnt];
10655
10656 hashes_cnt++;
10657 }
10658 else
10659 {
10660 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10661 }
10662
10663
10664 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10665
10666 hash_t *lm_hash_right = NULL;
10667
10668 if (parser_status == PARSER_OK)
10669 {
10670 lm_hash_right = &hashes_buf[hashes_cnt];
10671
10672 hashes_cnt++;
10673 }
10674 else
10675 {
10676 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10677 }
10678
10679 // show / left
10680
10681 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10682 {
10683 if (show == 1) handle_show_request_lm (pot, pot_cnt, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
10684 if (left == 1) handle_left_request_lm (pot, pot_cnt, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
10685 }
10686 }
10687 else
10688 {
10689 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10690
10691 if (parser_status == PARSER_OK)
10692 {
10693 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10694 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10695 }
10696
10697 if (parser_status == PARSER_OK)
10698 {
10699 hashes_cnt++;
10700 }
10701 else
10702 {
10703 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10704 }
10705 }
10706 }
10707 else
10708 {
10709 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10710
10711 if (parser_status == PARSER_OK)
10712 {
10713 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10714 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10715 }
10716
10717 if (parser_status == PARSER_OK)
10718 {
10719 hashes_cnt++;
10720 }
10721 else
10722 {
10723 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10724 }
10725 }
10726 }
10727 }
10728 else if (hashlist_mode == HL_MODE_FILE)
10729 {
10730 char *hashfile = data.hashfile;
10731
10732 FILE *fp;
10733
10734 if ((fp = fopen (hashfile, "rb")) == NULL)
10735 {
10736 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10737
10738 return (-1);
10739 }
10740
10741 uint line_num = 0;
10742
10743 while (!feof (fp))
10744 {
10745 line_num++;
10746
10747 char line_buf[BUFSIZ];
10748
10749 int line_len = fgetl (fp, line_buf);
10750
10751 if (line_len == 0) continue;
10752
10753 char *hash_buf = NULL;
10754 int hash_len = 0;
10755
10756 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10757
10758 if (username)
10759 {
10760 char *user_buf = NULL;
10761 int user_len = 0;
10762
10763 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10764
10765 if (remove || show)
10766 {
10767 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10768
10769 *user = (user_t *) malloc (sizeof (user_t));
10770
10771 user_t *user_ptr = *user;
10772
10773 if (user_buf != NULL)
10774 {
10775 user_ptr->user_name = mystrdup (user_buf);
10776 }
10777 else
10778 {
10779 user_ptr->user_name = mystrdup ("");
10780 }
10781
10782 user_ptr->user_len = user_len;
10783 }
10784 }
10785
10786 if (opts_type & OPTS_TYPE_HASH_COPY)
10787 {
10788 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10789
10790 hash_info_tmp->orighash = mystrdup (hash_buf);
10791 }
10792
10793 if (isSalted)
10794 {
10795 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10796 }
10797
10798 if (hash_mode == 3000)
10799 {
10800 if (hash_len == 32)
10801 {
10802 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10803
10804 if (parser_status < PARSER_GLOBAL_ZERO)
10805 {
10806 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10807
10808 continue;
10809 }
10810
10811 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10812
10813 hashes_cnt++;
10814
10815 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10816
10817 if (parser_status < PARSER_GLOBAL_ZERO)
10818 {
10819 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10820
10821 continue;
10822 }
10823
10824 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10825
10826 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
10827
10828 hashes_cnt++;
10829
10830 // show / left
10831
10832 if (show == 1) handle_show_request_lm (pot, pot_cnt, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
10833 if (left == 1) handle_left_request_lm (pot, pot_cnt, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
10834 }
10835 else
10836 {
10837 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10838
10839 if (parser_status < PARSER_GLOBAL_ZERO)
10840 {
10841 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10842
10843 continue;
10844 }
10845
10846 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
10847
10848 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10849 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10850
10851 hashes_cnt++;
10852 }
10853 }
10854 else
10855 {
10856 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10857
10858 if (parser_status < PARSER_GLOBAL_ZERO)
10859 {
10860 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10861
10862 continue;
10863 }
10864
10865 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
10866
10867 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10868 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10869
10870 hashes_cnt++;
10871 }
10872 }
10873
10874 fclose (fp);
10875
10876 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10877
10878 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10879 }
10880 }
10881 else
10882 {
10883 if (isSalted)
10884 {
10885 hashes_buf[0].salt->salt_len = 8;
10886
10887 // special salt handling
10888
10889 switch (hash_mode)
10890 {
10891 case 1500: hashes_buf[0].salt->salt_len = 2;
10892 break;
10893 case 1731: hashes_buf[0].salt->salt_len = 4;
10894 break;
10895 case 2410: hashes_buf[0].salt->salt_len = 4;
10896 break;
10897 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10898 break;
10899 case 3100: hashes_buf[0].salt->salt_len = 1;
10900 break;
10901 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10902 break;
10903 case 5800: hashes_buf[0].salt->salt_len = 16;
10904 break;
10905 case 6800: hashes_buf[0].salt->salt_len = 32;
10906 break;
10907 case 8400: hashes_buf[0].salt->salt_len = 40;
10908 break;
10909 case 8800: hashes_buf[0].salt->salt_len = 16;
10910 break;
10911 case 8900: hashes_buf[0].salt->salt_len = 16;
10912 hashes_buf[0].salt->scrypt_N = 1024;
10913 hashes_buf[0].salt->scrypt_r = 1;
10914 hashes_buf[0].salt->scrypt_p = 1;
10915 break;
10916 case 9100: hashes_buf[0].salt->salt_len = 16;
10917 break;
10918 case 9300: hashes_buf[0].salt->salt_len = 14;
10919 hashes_buf[0].salt->scrypt_N = 16384;
10920 hashes_buf[0].salt->scrypt_r = 1;
10921 hashes_buf[0].salt->scrypt_p = 1;
10922 break;
10923 case 9400: hashes_buf[0].salt->salt_len = 16;
10924 break;
10925 case 9500: hashes_buf[0].salt->salt_len = 16;
10926 break;
10927 case 9600: hashes_buf[0].salt->salt_len = 16;
10928 break;
10929 case 9700: hashes_buf[0].salt->salt_len = 16;
10930 break;
10931 case 9710: hashes_buf[0].salt->salt_len = 16;
10932 break;
10933 case 9720: hashes_buf[0].salt->salt_len = 16;
10934 break;
10935 case 9800: hashes_buf[0].salt->salt_len = 16;
10936 break;
10937 case 9810: hashes_buf[0].salt->salt_len = 16;
10938 break;
10939 case 9820: hashes_buf[0].salt->salt_len = 16;
10940 break;
10941 case 10300: hashes_buf[0].salt->salt_len = 12;
10942 break;
10943 case 11500: hashes_buf[0].salt->salt_len = 4;
10944 break;
10945 case 11600: hashes_buf[0].salt->salt_len = 4;
10946 break;
10947 case 12400: hashes_buf[0].salt->salt_len = 4;
10948 break;
10949 case 12500: hashes_buf[0].salt->salt_len = 8;
10950 break;
10951 case 12600: hashes_buf[0].salt->salt_len = 64;
10952 break;
10953 }
10954
10955 // special esalt handling
10956
10957 switch (hash_mode)
10958 {
10959 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
10960 break;
10961 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10962 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10963 break;
10964 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10965 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10966 break;
10967 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10968 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10969 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10970 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10971 break;
10972 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10973 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10974 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10975 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10976 break;
10977 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
10978 break;
10979 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10980 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10981 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10982 break;
10983 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10984 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10985 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10986 break;
10987 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10988 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10989 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10990 break;
10991 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10992 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10993 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10994 break;
10995 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10996 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
10997 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
10998 break;
10999 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11000 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11001 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11002 break;
11003 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11004 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11005 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11006 break;
11007 }
11008 }
11009
11010 // set hashfile
11011
11012 switch (hash_mode)
11013 {
11014 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11015 break;
11016 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11017 break;
11018 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11019 break;
11020 case 6211:
11021 case 6212:
11022 case 6213:
11023 case 6221:
11024 case 6222:
11025 case 6223:
11026 case 6231:
11027 case 6232:
11028 case 6233:
11029 case 6241:
11030 case 6242:
11031 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11032 break;
11033 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11034 break;
11035 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11036 break;
11037 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11038 break;
11039 }
11040
11041 // set default iterations
11042
11043 switch (hash_mode)
11044 {
11045 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11046 break;
11047 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11048 break;
11049 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11050 break;
11051 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11052 break;
11053 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11054 break;
11055 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11056 break;
11057 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11058 break;
11059 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11060 break;
11061 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11062 break;
11063 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11064 break;
11065 case 6211:
11066 case 6212:
11067 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11068 break;
11069 case 6221:
11070 case 6222:
11071 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11072 break;
11073 case 6231:
11074 case 6232:
11075 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11076 break;
11077 case 6241:
11078 case 6242:
11079 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11080 break;
11081 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11082 break;
11083 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11084 break;
11085 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11086 break;
11087 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11088 break;
11089 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11090 break;
11091 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11092 break;
11093 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11094 break;
11095 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11096 break;
11097 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11098 break;
11099 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11100 break;
11101 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11102 break;
11103 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11104 break;
11105 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11106 break;
11107 case 8900: hashes_buf[0].salt->salt_iter = 1;
11108 break;
11109 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11110 break;
11111 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11112 break;
11113 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11114 break;
11115 case 9300: hashes_buf[0].salt->salt_iter = 1;
11116 break;
11117 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11118 break;
11119 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11120 break;
11121 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11122 break;
11123 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11124 break;
11125 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11126 break;
11127 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11128 break;
11129 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11130 break;
11131 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11132 break;
11133 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11134 break;
11135 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11136 break;
11137 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11138 break;
11139 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11140 break;
11141 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11142 break;
11143 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11144 break;
11145 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11146 break;
11147 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11148 break;
11149 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11150 break;
11151 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11152 break;
11153 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11154 break;
11155 }
11156
11157 // set special tuning for benchmark-mode 1
11158
11159 if (benchmark_mode == 1)
11160 {
11161 kernel_loops *= 8;
11162 kernel_accel *= 4;
11163
11164 switch (hash_mode)
11165 {
11166 case 400: kernel_loops = ROUNDS_PHPASS;
11167 kernel_accel = 32;
11168 break;
11169 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11170 kernel_accel = 32;
11171 break;
11172 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11173 kernel_accel = 32;
11174 break;
11175 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11176 kernel_accel = 32;
11177 break;
11178 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11179 kernel_accel = 16;
11180 break;
11181 case 2100: kernel_loops = ROUNDS_DCC2;
11182 kernel_accel = 16;
11183 break;
11184 case 2500: kernel_loops = ROUNDS_WPA2;
11185 kernel_accel = 32;
11186 break;
11187 case 3200: kernel_loops = ROUNDS_BCRYPT;
11188 kernel_accel = 8;
11189 break;
11190 case 5200: kernel_loops = ROUNDS_PSAFE3;
11191 kernel_accel = 16;
11192 break;
11193 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11194 kernel_accel = 16;
11195 break;
11196 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11197 kernel_accel = 64;
11198 break;
11199 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11200 kernel_accel = 32;
11201 break;
11202 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11203 kernel_accel = 32;
11204 break;
11205 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11206 kernel_accel = 8;
11207 break;
11208 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11209 kernel_accel = 8;
11210 break;
11211 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11212 kernel_accel = 8;
11213 break;
11214 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11215 kernel_accel = 8;
11216 break;
11217 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11218 kernel_accel = 8;
11219 break;
11220 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11221 kernel_accel = 8;
11222 break;
11223 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11224 kernel_accel = 128;
11225 break;
11226 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11227 kernel_accel = 64;
11228 break;
11229 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11230 kernel_accel = 64;
11231 break;
11232 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11233 kernel_accel = 32;
11234 break;
11235 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11236 kernel_accel = 128;
11237 break;
11238 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11239 kernel_accel = 128;
11240 break;
11241 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11242 kernel_accel = 32;
11243 break;
11244 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11245 kernel_accel = 64;
11246 break;
11247 case 6800: kernel_loops = ROUNDS_LASTPASS;
11248 kernel_accel = 64;
11249 break;
11250 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11251 kernel_accel = 8;
11252 break;
11253 case 7200: kernel_loops = ROUNDS_GRUB;
11254 kernel_accel = 16;
11255 break;
11256 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11257 kernel_accel = 8;
11258 break;
11259 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11260 kernel_accel = 8;
11261 break;
11262 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11263 kernel_accel = 8;
11264 break;
11265 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11266 kernel_accel = 32;
11267 break;
11268 case 8900: kernel_loops = 1;
11269 kernel_accel = 64;
11270 break;
11271 case 9000: kernel_loops = ROUNDS_PSAFE2;
11272 kernel_accel = 16;
11273 break;
11274 case 9100: kernel_loops = ROUNDS_LOTUS8;
11275 kernel_accel = 64;
11276 break;
11277 case 9200: kernel_loops = ROUNDS_CISCO8;
11278 kernel_accel = 8;
11279 break;
11280 case 9300: kernel_loops = 1;
11281 kernel_accel = 4;
11282 break;
11283 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11284 kernel_accel = 32;
11285 break;
11286 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11287 kernel_accel = 32;
11288 break;
11289 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11290 kernel_accel = 8;
11291 break;
11292 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11293 kernel_accel = 8;
11294 break;
11295 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11296 kernel_accel = 16;
11297 break;
11298 case 10500: kernel_loops = ROUNDS_PDF14;
11299 kernel_accel = 256;
11300 break;
11301 case 10700: kernel_loops = ROUNDS_PDF17L8;
11302 kernel_accel = 8;
11303 break;
11304 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11305 kernel_accel = 8;
11306 break;
11307 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11308 kernel_accel = 8;
11309 break;
11310 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11311 kernel_accel = 8;
11312 break;
11313 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11314 kernel_accel = 8;
11315 break;
11316 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11317 kernel_accel = 8;
11318 break;
11319 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11320 kernel_accel = 8;
11321 break;
11322 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11323 kernel_accel = 8;
11324 break;
11325 case 12300: kernel_loops = ROUNDS_ORACLET;
11326 kernel_accel = 8;
11327 break;
11328 case 12500: kernel_loops = ROUNDS_RAR3;
11329 kernel_accel = 32;
11330 break;
11331 case 12700: kernel_loops = ROUNDS_MYWALLET;
11332 kernel_accel = 512;
11333 break;
11334 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11335 kernel_accel = 512;
11336 break;
11337 }
11338
11339 // some algorithm collide too fast, make that impossible
11340
11341 switch (hash_mode)
11342 {
11343 case 11500: ((uint *) digests_buf)[1] = 1;
11344 break;
11345 }
11346
11347 if (kernel_loops > 1024) kernel_loops = 1024;
11348 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11349 }
11350
11351 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11352 {
11353 kernel_loops = 1024;
11354 }
11355
11356 if (hash_mode == 12500)
11357 {
11358 kernel_loops = ROUNDS_RAR3 / 16;
11359 }
11360
11361 data.kernel_accel = kernel_accel;
11362 data.kernel_loops = kernel_loops;
11363
11364 hashes_cnt = 1;
11365 }
11366
11367 if (show == 1 || left == 1)
11368 {
11369 for (uint i = 0; i < pot_cnt; i++)
11370 {
11371 pot_t *pot_ptr = &pot[i];
11372
11373 hash_t *hashes_buf = &pot_ptr->hash;
11374
11375 local_free (hashes_buf->digest);
11376
11377 if (isSalted)
11378 {
11379 local_free (hashes_buf->salt);
11380 }
11381 }
11382
11383 local_free (pot);
11384
11385 if (data.quiet == 0) log_info_nn ("");
11386
11387 return (0);
11388 }
11389
11390 if (keyspace == 0)
11391 {
11392 if (hashes_cnt == 0)
11393 {
11394 log_error ("ERROR: No hashes loaded");
11395
11396 return (-1);
11397 }
11398 }
11399
11400 /**
11401 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11402 */
11403
11404 if (data.outfile != NULL)
11405 {
11406 if (data.hashfile != NULL)
11407 {
11408 #ifdef _POSIX
11409 struct stat tmpstat_outfile;
11410 struct stat tmpstat_hashfile;
11411 #endif
11412
11413 #ifdef _WIN
11414 struct stat64 tmpstat_outfile;
11415 struct stat64 tmpstat_hashfile;
11416 #endif
11417
11418 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11419
11420 if (tmp_outfile_fp)
11421 {
11422 #ifdef _POSIX
11423 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11424 #endif
11425
11426 #ifdef _WIN
11427 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11428 #endif
11429
11430 fclose (tmp_outfile_fp);
11431 }
11432
11433 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11434
11435 if (tmp_hashfile_fp)
11436 {
11437 #ifdef _POSIX
11438 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11439 #endif
11440
11441 #ifdef _WIN
11442 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11443 #endif
11444
11445 fclose (tmp_hashfile_fp);
11446 }
11447
11448 if (tmp_outfile_fp && tmp_outfile_fp)
11449 {
11450 tmpstat_outfile.st_mode = 0;
11451 tmpstat_outfile.st_nlink = 0;
11452 tmpstat_outfile.st_uid = 0;
11453 tmpstat_outfile.st_gid = 0;
11454 tmpstat_outfile.st_rdev = 0;
11455 tmpstat_outfile.st_atime = 0;
11456
11457 tmpstat_hashfile.st_mode = 0;
11458 tmpstat_hashfile.st_nlink = 0;
11459 tmpstat_hashfile.st_uid = 0;
11460 tmpstat_hashfile.st_gid = 0;
11461 tmpstat_hashfile.st_rdev = 0;
11462 tmpstat_hashfile.st_atime = 0;
11463
11464 #ifdef _POSIX
11465 tmpstat_outfile.st_blksize = 0;
11466 tmpstat_outfile.st_blocks = 0;
11467
11468 tmpstat_hashfile.st_blksize = 0;
11469 tmpstat_hashfile.st_blocks = 0;
11470 #endif
11471
11472 #ifdef _POSIX
11473 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11474 {
11475 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11476
11477 return (-1);
11478 }
11479 #endif
11480
11481 #ifdef _WIN
11482 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11483 {
11484 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11485
11486 return (-1);
11487 }
11488 #endif
11489 }
11490 }
11491 }
11492
11493 /**
11494 * Remove duplicates
11495 */
11496
11497 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11498
11499 if (isSalted)
11500 {
11501 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11502 }
11503 else
11504 {
11505 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11506 }
11507
11508 uint hashes_cnt_orig = hashes_cnt;
11509
11510 hashes_cnt = 1;
11511
11512 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11513 {
11514 if (isSalted)
11515 {
11516 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11517 {
11518 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11519 }
11520 }
11521 else
11522 {
11523 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11524 }
11525
11526 if (hashes_pos > hashes_cnt)
11527 {
11528 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11529 }
11530
11531 hashes_cnt++;
11532 }
11533
11534 /**
11535 * Potfile removes
11536 */
11537
11538 uint potfile_remove_cracks = 0;
11539
11540 if (potfile_disable == 0)
11541 {
11542 hash_t hash_buf;
11543
11544 hash_buf.digest = mymalloc (dgst_size);
11545 hash_buf.salt = NULL;
11546 hash_buf.esalt = NULL;
11547 hash_buf.hash_info = NULL;
11548 hash_buf.cracked = 0;
11549
11550 if (isSalted)
11551 {
11552 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11553 }
11554
11555 if (esalt_size)
11556 {
11557 hash_buf.esalt = mymalloc (esalt_size);
11558 }
11559
11560 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11561
11562 // no solution for these special hash types (for instane because they use hashfile in output etc)
11563 if ((hash_mode != 5200) &&
11564 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11565 (hash_mode != 9000))
11566 {
11567 FILE *fp = fopen (potfile, "rb");
11568
11569 if (fp != NULL)
11570 {
11571 while (!feof (fp))
11572 {
11573 char line_buf[BUFSIZ];
11574
11575 memset (line_buf, 0, BUFSIZ);
11576
11577 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11578
11579 if (ptr == NULL) break;
11580
11581 int line_len = strlen (line_buf);
11582
11583 if (line_len == 0) continue;
11584
11585 int iter = MAX_CUT_TRIES;
11586
11587 for (int i = line_len - 1; i && iter; i--, line_len--)
11588 {
11589 if (line_buf[i] != ':') continue;
11590
11591 if (isSalted)
11592 {
11593 memset (hash_buf.salt, 0, sizeof (salt_t));
11594 }
11595
11596 hash_t *found = NULL;
11597
11598 if (hash_mode == 6800)
11599 {
11600 if (i < 48) // 48 = 12 * uint in salt_buf[]
11601 {
11602 // manipulate salt_buf
11603 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11604
11605 hash_buf.salt->salt_len = i;
11606
11607 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11608 }
11609 }
11610 else if (hash_mode == 2500)
11611 {
11612 if (i < 48) // 48 = 12 * uint in salt_buf[]
11613 {
11614 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11615 // manipulate salt_buf
11616
11617 // to be safe work with a copy (because of line_len loop, i etc)
11618
11619 char line_buf_cpy[BUFSIZ];
11620 memset (line_buf_cpy, 0, BUFSIZ);
11621
11622 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11623
11624 memcpy (line_buf_cpy, line_buf, i);
11625
11626 char *mac2_pos = strrchr (line_buf_cpy, ':');
11627
11628 if (mac2_pos == NULL) continue;
11629
11630 mac2_pos[0] = 0;
11631 mac2_pos++;
11632
11633 if (strlen (mac2_pos) != 12) continue;
11634
11635 char *mac1_pos = strrchr (line_buf_cpy, ':');
11636
11637 if (mac1_pos == NULL) continue;
11638
11639 mac1_pos[0] = 0;
11640 mac1_pos++;
11641
11642 if (strlen (mac1_pos) != 12) continue;
11643
11644 uint essid_length = mac1_pos - line_buf_cpy - 1;
11645
11646 // here we need the ESSID
11647 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11648
11649 hash_buf.salt->salt_len = essid_length;
11650
11651 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11652
11653 if (found)
11654 {
11655 wpa_t *wpa = (wpa_t *) found->esalt;
11656
11657 uint pke[25];
11658
11659 char *pke_ptr = (char *) pke;
11660
11661 for (uint i = 0; i < 25; i++)
11662 {
11663 pke[i] = byte_swap_32 (wpa->pke[i]);
11664 }
11665
11666 unsigned char mac1[6];
11667 unsigned char mac2[6];
11668
11669 memcpy (mac1, pke_ptr + 23, 6);
11670 memcpy (mac2, pke_ptr + 29, 6);
11671
11672 // compare hex string(s) vs binary MAC address(es)
11673
11674 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11675 {
11676 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
11677 {
11678 found = NULL;
11679 break;
11680 }
11681 }
11682
11683 // early skip ;)
11684 if (!found) continue;
11685
11686 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11687 {
11688 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
11689 {
11690 found = NULL;
11691 break;
11692 }
11693 }
11694 }
11695 }
11696 }
11697 else
11698 {
11699 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11700
11701 if (parser_status == PARSER_OK)
11702 {
11703 if (isSalted)
11704 {
11705 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11706 }
11707 else
11708 {
11709 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11710 }
11711 }
11712 }
11713
11714 if (found == NULL) continue;
11715
11716 if (!found->cracked) potfile_remove_cracks++;
11717
11718 found->cracked = 1;
11719
11720 if (found) break;
11721
11722 iter--;
11723 }
11724 }
11725
11726 fclose (fp);
11727 }
11728 }
11729
11730 if (esalt_size)
11731 {
11732 local_free (hash_buf.esalt);
11733 }
11734
11735 if (isSalted)
11736 {
11737 local_free (hash_buf.salt);
11738 }
11739
11740 local_free (hash_buf.digest);
11741 }
11742
11743 /**
11744 * Now generate all the buffers required for later
11745 */
11746
11747 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11748
11749 salt_t *salts_buf_new = NULL;
11750 void *esalts_buf_new = NULL;
11751
11752 if (isSalted)
11753 {
11754 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11755
11756 if (esalt_size)
11757 {
11758 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11759 }
11760 }
11761 else
11762 {
11763 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11764 }
11765
11766 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11767
11768 uint digests_cnt = hashes_cnt;
11769 uint digests_done = 0;
11770
11771 uint size_digests = digests_cnt * dgst_size;
11772 uint size_shown = digests_cnt * sizeof (uint);
11773
11774 uint *digests_shown = (uint *) mymalloc (size_shown);
11775 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11776
11777 uint salts_cnt = 0;
11778 uint salts_done = 0;
11779
11780 hashinfo_t **hash_info = NULL;
11781
11782 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11783 {
11784 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11785
11786 if (username && (remove || show))
11787 {
11788 uint user_pos;
11789
11790 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11791 {
11792 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11793
11794 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11795 }
11796 }
11797 }
11798
11799 uint *salts_shown = (uint *) mymalloc (size_shown);
11800
11801 salt_t *salt_buf;
11802
11803 {
11804 // copied from inner loop
11805
11806 salt_buf = &salts_buf_new[salts_cnt];
11807
11808 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11809
11810 if (esalt_size)
11811 {
11812 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11813 }
11814
11815 salt_buf->digests_cnt = 0;
11816 salt_buf->digests_done = 0;
11817 salt_buf->digests_offset = 0;
11818
11819 salts_cnt++;
11820 }
11821
11822 if (hashes_buf[0].cracked == 1)
11823 {
11824 digests_shown[0] = 1;
11825
11826 digests_done++;
11827
11828 salt_buf->digests_done++;
11829 }
11830
11831 salt_buf->digests_cnt++;
11832
11833 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11834
11835 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11836 {
11837 hash_info[0] = hashes_buf[0].hash_info;
11838 }
11839
11840 // copy from inner loop
11841
11842 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11843 {
11844 if (isSalted)
11845 {
11846 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11847 {
11848 salt_buf = &salts_buf_new[salts_cnt];
11849
11850 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11851
11852 if (esalt_size)
11853 {
11854 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11855 }
11856
11857 salt_buf->digests_cnt = 0;
11858 salt_buf->digests_done = 0;
11859 salt_buf->digests_offset = hashes_pos;
11860
11861 salts_cnt++;
11862 }
11863 }
11864
11865 if (hashes_buf[hashes_pos].cracked == 1)
11866 {
11867 digests_shown[hashes_pos] = 1;
11868
11869 digests_done++;
11870
11871 salt_buf->digests_done++;
11872 }
11873
11874 salt_buf->digests_cnt++;
11875
11876 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11877
11878 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11879 {
11880 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11881 }
11882 }
11883
11884 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11885 {
11886 salt_t *salt_buf = &salts_buf_new[salt_pos];
11887
11888 if (salt_buf->digests_done == salt_buf->digests_cnt)
11889 {
11890 salts_shown[salt_pos] = 1;
11891
11892 salts_done++;
11893 }
11894
11895 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11896 }
11897
11898 local_free (digests_buf);
11899 local_free (salts_buf);
11900 local_free (esalts_buf);
11901
11902 digests_buf = digests_buf_new;
11903 salts_buf = salts_buf_new;
11904 esalts_buf = esalts_buf_new;
11905
11906 local_free (hashes_buf);
11907
11908 /**
11909 * special modification not set from parser
11910 */
11911
11912 switch (hash_mode)
11913 {
11914 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11915 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11916 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11917 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11918 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11919 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11920 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11921 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11922 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11923 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11924 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11925 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11926 }
11927
11928 if (truecrypt_keyfiles)
11929 {
11930 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11931
11932 char *keyfiles = strdup (truecrypt_keyfiles);
11933
11934 char *keyfile = strtok (keyfiles, ",");
11935
11936 do
11937 {
11938 truecrypt_crc32 (keyfile, (unsigned char *) keyfile_buf);
11939
11940 } while ((keyfile = strtok (NULL, ",")) != NULL);
11941
11942 free (keyfiles);
11943 }
11944
11945 data.digests_cnt = digests_cnt;
11946 data.digests_done = digests_done;
11947 data.digests_buf = digests_buf;
11948 data.digests_shown = digests_shown;
11949 data.digests_shown_tmp = digests_shown_tmp;
11950
11951 data.salts_cnt = salts_cnt;
11952 data.salts_done = salts_done;
11953 data.salts_buf = salts_buf;
11954 data.salts_shown = salts_shown;
11955
11956 data.esalts_buf = esalts_buf;
11957 data.hash_info = hash_info;
11958
11959 /**
11960 * Automatic Optimizers
11961 */
11962
11963 if (salts_cnt == 1)
11964 opti_type |= OPTI_TYPE_SINGLE_SALT;
11965
11966 if (digests_cnt == 1)
11967 opti_type |= OPTI_TYPE_SINGLE_HASH;
11968
11969 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11970 opti_type |= OPTI_TYPE_NOT_ITERATED;
11971
11972 if (attack_mode == ATTACK_MODE_BF)
11973 opti_type |= OPTI_TYPE_BRUTE_FORCE;
11974
11975 data.opti_type = opti_type;
11976
11977 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
11978 {
11979 if (opti_type & OPTI_TYPE_SINGLE_HASH)
11980 {
11981 if (opti_type & OPTI_TYPE_APPENDED_SALT)
11982 {
11983 if (opts_type & OPTS_TYPE_ST_ADD80)
11984 {
11985 opts_type &= ~OPTS_TYPE_ST_ADD80;
11986 opts_type |= OPTS_TYPE_PT_ADD80;
11987 }
11988
11989 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
11990 {
11991 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
11992 opts_type |= OPTS_TYPE_PT_ADDBITS14;
11993 }
11994
11995 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
11996 {
11997 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
11998 opts_type |= OPTS_TYPE_PT_ADDBITS15;
11999 }
12000 }
12001 }
12002 }
12003
12004 /**
12005 * Some algorithm, like descrypt, can benefit from JIT compilation
12006 */
12007
12008 uint force_jit_compilation = 0;
12009
12010 if (hash_mode == 8900)
12011 {
12012 force_jit_compilation = 8900;
12013 }
12014 else if (hash_mode == 9300)
12015 {
12016 force_jit_compilation = 8900;
12017 }
12018 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12019 {
12020 force_jit_compilation = 1500;
12021 }
12022
12023 /**
12024 * generate bitmap tables
12025 */
12026
12027 const uint bitmap_shift1 = 5;
12028 const uint bitmap_shift2 = 13;
12029
12030 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12031
12032 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12033 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12034 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12035 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12036 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12037 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12038 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12039 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12040
12041 uint bitmap_bits;
12042 uint bitmap_nums;
12043 uint bitmap_mask;
12044 uint bitmap_size;
12045
12046 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12047 {
12048 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12049
12050 bitmap_nums = 1 << bitmap_bits;
12051
12052 bitmap_mask = bitmap_nums - 1;
12053
12054 bitmap_size = bitmap_nums * sizeof (uint);
12055
12056 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12057
12058 if (generate_bitmaps (digests_cnt, dgst_size, bitmap_shift1, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, digests_cnt / 2) == 0x7fffffff) continue;
12059 if (generate_bitmaps (digests_cnt, dgst_size, bitmap_shift2, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, digests_cnt / 2) == 0x7fffffff) continue;
12060
12061 break;
12062 }
12063
12064 bitmap_nums = 1 << bitmap_bits;
12065
12066 bitmap_mask = bitmap_nums - 1;
12067
12068 bitmap_size = bitmap_nums * sizeof (uint);
12069
12070 generate_bitmaps (digests_cnt, dgst_size, bitmap_shift1, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, -1);
12071 generate_bitmaps (digests_cnt, dgst_size, bitmap_shift2, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s2_a, bitmap_s2_b, bitmap_s2_c, bitmap_s2_d, -1);
12072
12073 /**
12074 * prepare quick rule
12075 */
12076
12077 data.rule_buf_l = rule_buf_l;
12078 data.rule_buf_r = rule_buf_r;
12079
12080 int rule_len_l = (int) strlen (rule_buf_l);
12081 int rule_len_r = (int) strlen (rule_buf_r);
12082
12083 data.rule_len_l = rule_len_l;
12084 data.rule_len_r = rule_len_r;
12085
12086 /**
12087 * load rules
12088 */
12089
12090 uint *all_kernel_rules_cnt = NULL;
12091
12092 kernel_rule_t **all_kernel_rules_buf = NULL;
12093
12094 if (rp_files_cnt)
12095 {
12096 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12097
12098 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12099 }
12100
12101 char rule_buf[BUFSIZ];
12102
12103 int rule_len = 0;
12104
12105 for (uint i = 0; i < rp_files_cnt; i++)
12106 {
12107 uint kernel_rules_avail = 0;
12108
12109 uint kernel_rules_cnt = 0;
12110
12111 kernel_rule_t *kernel_rules_buf = NULL;
12112
12113 char *rp_file = rp_files[i];
12114
12115 char in[BLOCK_SIZE];
12116 char out[BLOCK_SIZE];
12117
12118 FILE *fp = NULL;
12119
12120 uint rule_line = 0;
12121
12122 if ((fp = fopen (rp_file, "rb")) == NULL)
12123 {
12124 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12125
12126 return (-1);
12127 }
12128
12129 while (!feof (fp))
12130 {
12131 memset (rule_buf, 0, BUFSIZ);
12132
12133 rule_len = fgetl (fp, rule_buf);
12134
12135 rule_line++;
12136
12137 if (rule_len == 0) continue;
12138
12139 if (rule_buf[0] == '#') continue;
12140
12141 if (kernel_rules_avail == kernel_rules_cnt)
12142 {
12143 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12144
12145 kernel_rules_avail += INCR_RULES;
12146 }
12147
12148 memset (in, 0, BLOCK_SIZE);
12149 memset (out, 0, BLOCK_SIZE);
12150
12151 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12152
12153 if (result == -1)
12154 {
12155 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12156
12157 continue;
12158 }
12159
12160 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12161 {
12162 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12163
12164 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12165
12166 continue;
12167 }
12168
12169 /* its so slow
12170 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12171 {
12172 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12173
12174 continue;
12175 }
12176 */
12177
12178 kernel_rules_cnt++;
12179 }
12180
12181 fclose (fp);
12182
12183 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12184
12185 all_kernel_rules_buf[i] = kernel_rules_buf;
12186 }
12187
12188 /**
12189 * merge rules or automatic rule generator
12190 */
12191
12192 uint kernel_rules_cnt = 0;
12193
12194 kernel_rule_t *kernel_rules_buf = NULL;
12195
12196 if (attack_mode == ATTACK_MODE_STRAIGHT)
12197 {
12198 if (rp_files_cnt)
12199 {
12200 kernel_rules_cnt = 1;
12201
12202 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12203
12204 repeats[0] = kernel_rules_cnt;
12205
12206 for (uint i = 0; i < rp_files_cnt; i++)
12207 {
12208 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12209
12210 repeats[i + 1] = kernel_rules_cnt;
12211 }
12212
12213 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12214
12215 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12216
12217 for (uint i = 0; i < kernel_rules_cnt; i++)
12218 {
12219 uint out_pos = 0;
12220
12221 kernel_rule_t *out = &kernel_rules_buf[i];
12222
12223 for (uint j = 0; j < rp_files_cnt; j++)
12224 {
12225 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12226 uint in_pos;
12227
12228 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12229
12230 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12231 {
12232 if (out_pos == RULES_MAX - 1)
12233 {
12234 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12235
12236 break;
12237 }
12238
12239 out->cmds[out_pos] = in->cmds[in_pos];
12240 }
12241 }
12242 }
12243
12244 local_free (repeats);
12245 }
12246 else if (rp_gen)
12247 {
12248 uint kernel_rules_avail = 0;
12249
12250 while (kernel_rules_cnt < rp_gen)
12251 {
12252 if (kernel_rules_avail == kernel_rules_cnt)
12253 {
12254 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12255
12256 kernel_rules_avail += INCR_RULES;
12257 }
12258
12259 memset (rule_buf, 0, BLOCK_SIZE);
12260
12261 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12262
12263 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12264
12265 kernel_rules_cnt++;
12266 }
12267 }
12268 }
12269
12270 /**
12271 * generate NOP rules
12272 */
12273
12274 if (kernel_rules_cnt == 0)
12275 {
12276 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12277
12278 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12279
12280 kernel_rules_cnt++;
12281 }
12282
12283 data.kernel_rules_cnt = kernel_rules_cnt;
12284 data.kernel_rules_buf = kernel_rules_buf;
12285
12286 /**
12287 * platform
12288 */
12289
12290 cl_platform_id CL_platforms[CL_PLATFORMS_MAX];
12291
12292 uint CL_platforms_cnt = 0;
12293
12294 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, CL_platforms, &CL_platforms_cnt);
12295
12296 if (CL_platforms_cnt == 0)
12297 {
12298 log_error ("ERROR: No OpenCL compatible platform found");
12299
12300 return (-1);
12301 }
12302
12303 uint CL_platform_sel = 1;
12304
12305 if (opencl_platform != NULL)
12306 {
12307 CL_platform_sel = atoi (opencl_platform);
12308 }
12309
12310 if (CL_platforms_cnt > 1)
12311 {
12312 if (opencl_platform == NULL)
12313 {
12314 log_error ("ERROR: Too many OpenCL compatible platforms found");
12315
12316 log_info ("Please select a single platform using the --opencl-platform option");
12317 log_info ("");
12318 log_info ("Available OpenCL platforms:");
12319 log_info ("");
12320
12321 for (uint i = 0; i < CL_platforms_cnt; i++)
12322 {
12323 char CL_platform_vendor[INFOSZ];
12324
12325 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12326
12327 hc_clGetPlatformInfo (CL_platforms[i], CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12328
12329 log_info ("* %d = %s", i + 1, CL_platform_vendor);
12330 }
12331
12332 log_info ("");
12333
12334 return (-1);
12335 }
12336 else
12337 {
12338 if (CL_platform_sel > CL_platforms_cnt)
12339 {
12340 log_error ("ERROR: invalid OpenCL platforms selected");
12341
12342 return (-1);
12343 }
12344 }
12345 }
12346 else
12347 {
12348 if (CL_platform_sel != 1)
12349 {
12350 log_error ("ERROR: OpenCL platform number %d not available", CL_platform_sel);
12351
12352 return (-1);
12353 }
12354 }
12355
12356 // zero-indexed: not starting to count at 1, as user does
12357
12358 CL_platform_sel -= 1;
12359
12360
12361 cl_platform_id CL_platform = CL_platforms[CL_platform_sel];
12362
12363 char CL_platform_vendor[INFOSZ];
12364
12365 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12366
12367 hc_clGetPlatformInfo (CL_platform, CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12368
12369 cl_device_type device_type;
12370
12371 uint vendor_id;
12372
12373 if (strcmp (CL_platform_vendor, CL_VENDOR_AMD) == 0)
12374 {
12375 vendor_id = VENDOR_ID_AMD;
12376
12377 device_type = CL_DEVICE_TYPE_GPU;
12378 }
12379 else if (strcmp (CL_platform_vendor, CL_VENDOR_NV) == 0)
12380 {
12381 vendor_id = VENDOR_ID_NV;
12382
12383 device_type = CL_DEVICE_TYPE_GPU;
12384
12385 // make sure that we do not directly control the fan for NVidia
12386
12387 gpu_temp_retain = 0;
12388
12389 data.gpu_temp_retain = gpu_temp_retain;
12390 }
12391 else if (strcmp (CL_platform_vendor, CL_VENDOR_POCL) == 0)
12392 {
12393 vendor_id = VENDOR_ID_POCL;
12394
12395 device_type = CL_DEVICE_TYPE_CPU;
12396
12397 gpu_temp_disable = 1;
12398 }
12399 else
12400 {
12401 vendor_id = VENDOR_ID_UNKNOWN;
12402
12403 device_type = CL_DEVICE_TYPE_DEFAULT;
12404 }
12405
12406 if (vendor_id == VENDOR_ID_UNKNOWN)
12407 {
12408 log_error ("Warning: unknown OpenCL vendor '%s' detected", CL_platform_vendor);
12409
12410 gpu_temp_disable = 1;
12411 }
12412
12413 data.vendor_id = vendor_id;
12414
12415 /**
12416 * cached kernel path depends on vendor_id which we don't know, so create it here
12417 */
12418
12419 int vendor_id_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 10 + 1;
12420
12421 char *vendor_id_folder = (char *) mymalloc (vendor_id_folder_size);
12422
12423 snprintf (vendor_id_folder, vendor_id_folder_size - 1, "%s/kernels", profile_dir);
12424
12425 mkdir (vendor_id_folder, 0700);
12426
12427 snprintf (vendor_id_folder, vendor_id_folder_size - 1, "%s/kernels/%d", profile_dir, vendor_id);
12428
12429 mkdir (vendor_id_folder, 0700);
12430
12431 myfree (vendor_id_folder);
12432
12433 /**
12434 * devices
12435 */
12436
12437 cl_device_id devices_all[DEVICES_MAX];
12438 cl_device_id devices[DEVICES_MAX];
12439
12440 uint devices_all_cnt = 0;
12441
12442 hc_clGetDeviceIDs (CL_platform, device_type, DEVICES_MAX, devices_all, (uint *) &devices_all_cnt);
12443
12444 int hm_adapters_all = devices_all_cnt;
12445
12446 hm_attrs_t hm_adapter_all[DEVICES_MAX];
12447
12448 memset (hm_adapter_all, 0, sizeof (hm_adapter_all));
12449
12450 if (gpu_temp_disable == 0)
12451 {
12452 if (vendor_id == VENDOR_ID_NV)
12453 {
12454 #ifdef LINUX
12455 HM_LIB hm_dll = hm_init ();
12456
12457 data.hm_dll = hm_dll;
12458
12459 if (hc_NVML_nvmlInit (hm_dll) == NVML_SUCCESS)
12460 {
12461 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12462
12463 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12464
12465 int tmp_out = 0;
12466
12467 for (int i = 0; i < tmp_in; i++)
12468 {
12469 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12470 }
12471
12472 hm_adapters_all = tmp_out;
12473
12474 for (int i = 0; i < tmp_out; i++)
12475 {
12476 unsigned int speed;
12477
12478 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;
12479 }
12480 }
12481 #endif
12482
12483 #ifdef WIN
12484 if (NvAPI_Initialize () == NVAPI_OK)
12485 {
12486 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12487
12488 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12489
12490 int tmp_out = 0;
12491
12492 for (int i = 0; i < tmp_in; i++)
12493 {
12494 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12495 }
12496
12497 hm_adapters_all = tmp_out;
12498
12499 for (int i = 0; i < tmp_out; i++)
12500 {
12501 NvU32 speed;
12502
12503 if (NvAPI_GPU_GetTachReading (hm_adapter_all[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12504 }
12505 }
12506 #endif
12507 }
12508
12509 if (vendor_id == VENDOR_ID_AMD)
12510 {
12511 HM_LIB hm_dll = hm_init ();
12512
12513 data.hm_dll = hm_dll;
12514
12515 if (hc_ADL_Main_Control_Create (hm_dll, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12516 {
12517 // total number of adapters
12518
12519 int hm_adapters_num;
12520
12521 if (get_adapters_num_amd (hm_dll, &hm_adapters_num) != 0) return (-1);
12522
12523 // adapter info
12524
12525 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll, hm_adapters_num);
12526
12527 if (lpAdapterInfo == NULL) return (-1);
12528
12529 // get a list (of ids of) valid/usable adapters
12530
12531 int num_adl_adapters = 0;
12532
12533 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12534
12535 if (num_adl_adapters > 0)
12536 {
12537 hc_thread_mutex_lock (mux_adl);
12538
12539 // hm_get_opencl_busid_devid (hm_adapter_all, devices_all_cnt, devices_all);
12540
12541 hm_get_adapter_index_amd (hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12542
12543 hm_get_overdrive_version (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12544 hm_check_fanspeed_control (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12545
12546 hc_thread_mutex_unlock (mux_adl);
12547 }
12548
12549 hm_adapters_all = num_adl_adapters;
12550
12551 myfree (valid_adl_device_list);
12552 myfree (lpAdapterInfo);
12553 }
12554 }
12555 }
12556
12557 if (hm_adapters_all == 0)
12558 {
12559 gpu_temp_disable = 1;
12560 }
12561
12562 if (gpu_temp_disable == 1)
12563 {
12564 gpu_temp_abort = 0;
12565 gpu_temp_retain = 0;
12566 }
12567
12568 /**
12569 * enable custom signal handler(s)
12570 */
12571
12572 if (benchmark == 0)
12573 {
12574 hc_signal (sigHandler_default);
12575 }
12576 else
12577 {
12578 hc_signal (sigHandler_benchmark);
12579 }
12580
12581 /**
12582 * devices mask and properties
12583 */
12584
12585 uint devices_cnt = 0;
12586
12587 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
12588 {
12589 if (opencl_devicemask)
12590 {
12591 uint device_all_id_mask = 1 << device_all_id;
12592
12593 if ((device_all_id_mask & opencl_devicemask) != device_all_id_mask)
12594 {
12595 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped by user", device_all_id_mask + 1);
12596
12597 continue;
12598 }
12599 }
12600
12601 const uint device_id = devices_cnt;
12602
12603 devices[device_id] = devices_all[device_all_id];
12604
12605 memcpy (&data.hm_device[device_id], &hm_adapter_all[device_all_id], sizeof (hm_attrs_t));
12606
12607 char device_name[INFOSZ];
12608
12609 memset (device_name, 0, sizeof (device_name));
12610
12611 cl_ulong global_mem_size;
12612 cl_ulong max_mem_alloc_size;
12613 cl_uint max_clock_frequency;
12614 cl_uint max_compute_units;
12615
12616 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
12617 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
12618 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12619 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
12620 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12621
12622 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12623 {
12624 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12625 device_all_id + 1,
12626 device_name,
12627 (unsigned int) (max_mem_alloc_size / 1024 / 1024),
12628 (unsigned int) (global_mem_size / 1024 / 1024),
12629 (unsigned int) (max_clock_frequency),
12630 (unsigned int) max_compute_units);
12631 }
12632
12633 devices_cnt++;
12634 }
12635
12636 if (devices_cnt == 0)
12637 {
12638 log_error ("ERROR: No devices left that matches your specification.");
12639
12640 return (-1);
12641 }
12642
12643 data.devices_cnt = devices_cnt;
12644
12645 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12646 {
12647 log_info ("");
12648 }
12649
12650 /**
12651 * inform the user
12652 */
12653
12654 // gpu temp sanity check
12655
12656 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12657 {
12658 if (gpu_temp_abort < gpu_temp_retain)
12659 {
12660 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12661
12662 return (-1);
12663 }
12664 }
12665
12666 data.gpu_temp_disable = gpu_temp_disable;
12667 data.gpu_temp_abort = gpu_temp_abort;
12668 data.gpu_temp_retain = gpu_temp_retain;
12669
12670 if (data.quiet == 0)
12671 {
12672 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12673
12674 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);
12675
12676 if (attack_mode == ATTACK_MODE_STRAIGHT)
12677 {
12678 log_info ("Rules: %u", kernel_rules_cnt);
12679 }
12680
12681 if (opti_type)
12682 {
12683 log_info ("Applicable Optimizers:");
12684
12685 for (uint i = 0; i < 32; i++)
12686 {
12687 const uint opti_bit = 1 << i;
12688
12689 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12690 }
12691 }
12692
12693 /**
12694 * Watchdog and Temperature balance
12695 */
12696
12697 if (gpu_temp_abort == 0)
12698 {
12699 log_info ("Watchdog: Temperature abort trigger disabled");
12700 }
12701 else
12702 {
12703 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12704 }
12705
12706 if (gpu_temp_retain == 0)
12707 {
12708 log_info ("Watchdog: Temperature retain trigger disabled");
12709 }
12710 else
12711 {
12712 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12713 }
12714 }
12715
12716 /**
12717 * devices init
12718 */
12719
12720 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12721
12722 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12723
12724 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12725
12726 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
12727
12728 data.devices_param = devices_param;
12729
12730 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12731 {
12732 hc_device_param_t *device_param = &data.devices_param[device_id];
12733
12734 cl_device_id device = devices[device_id];
12735
12736 device_param->device = device;
12737
12738 cl_device_type device_type = 0;
12739
12740 hc_clGetDeviceInfo (device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12741
12742 device_param->device_type = device_type;
12743
12744 cl_uint max_compute_units = 0;
12745
12746 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12747
12748 device_param->device_processors = max_compute_units;
12749
12750 cl_ulong max_mem_alloc_size = 0;
12751
12752 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12753
12754 device_param->device_maxmem_alloc = max_mem_alloc_size;
12755
12756 char tmp[INFOSZ], t1[64];
12757
12758 memset (tmp, 0, sizeof (tmp));
12759
12760 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
12761
12762 device_param->device_name = mystrdup (tmp);
12763
12764 memset (tmp, 0, sizeof (tmp));
12765
12766 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
12767
12768 memset (t1, 0, sizeof (t1));
12769
12770 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
12771
12772 device_param->device_version = mystrdup (t1);
12773
12774 memset (tmp, 0, sizeof (tmp));
12775
12776 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
12777
12778 device_param->driver_version = mystrdup (tmp);
12779
12780 // create some filename that is easier to read on cached folder
12781
12782 snprintf (tmp, sizeof (tmp) - 1, "%s-%s-%s-%d", device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12783
12784 uint device_name_digest[4];
12785
12786 device_name_digest[0] = 0;
12787 device_name_digest[1] = 0;
12788 device_name_digest[2] = 0;
12789 device_name_digest[3] = 0;
12790
12791 md5_64 ((uint *) tmp, device_name_digest);
12792
12793 sprintf (tmp, "%08x", device_name_digest[0]);
12794
12795 device_param->device_name_chksum = mystrdup (tmp);
12796
12797 if (device_type == CL_DEVICE_TYPE_CPU)
12798 {
12799 cl_uint device_processor_cores = 1;
12800
12801 device_param->device_processor_cores = device_processor_cores;
12802 }
12803
12804 if (device_type == CL_DEVICE_TYPE_GPU)
12805 {
12806 if (vendor_id == VENDOR_ID_AMD)
12807 {
12808 cl_uint device_processor_cores = 0;
12809
12810 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12811
12812 hc_clGetDeviceInfo (device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12813
12814 device_param->device_processor_cores = device_processor_cores;
12815 }
12816
12817 if (vendor_id == VENDOR_ID_NV)
12818 {
12819 cl_uint kernel_exec_timeout = 0;
12820
12821 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12822
12823 hc_clGetDeviceInfo (device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12824
12825 device_param->kernel_exec_timeout = kernel_exec_timeout;
12826
12827 cl_uint device_processor_cores = 0;
12828
12829 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12830
12831 hc_clGetDeviceInfo (device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12832
12833 device_param->device_processor_cores = device_processor_cores;
12834
12835 cl_uint sm_minor = 0;
12836 cl_uint sm_major = 0;
12837
12838 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12839 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12840
12841 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12842 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12843
12844 device_param->sm_minor = sm_minor;
12845 device_param->sm_major = sm_major;
12846 }
12847 }
12848
12849 /**
12850 * common driver check
12851 */
12852
12853 if (device_type == CL_DEVICE_TYPE_GPU)
12854 {
12855 if (vendor_id == VENDOR_ID_NV)
12856 {
12857 if (device_param->kernel_exec_timeout != 0)
12858 {
12859 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);
12860 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12861 }
12862 }
12863
12864 if (vendor_id == VENDOR_ID_AMD)
12865 {
12866 int catalyst_check = (force == 1) ? 0 : 1;
12867
12868 int catalyst_warn = 0;
12869
12870 int catalyst_broken = 0;
12871
12872 if (catalyst_check == 1)
12873 {
12874 catalyst_warn = 1;
12875
12876 // v14.9 and higher
12877 if ((atoi (device_param->device_version) >= 1573)
12878 && (atoi (device_param->driver_version) >= 1573))
12879 {
12880 catalyst_warn = 0;
12881 }
12882
12883 catalyst_check = 0;
12884 }
12885
12886 if (catalyst_broken == 1)
12887 {
12888 log_error ("");
12889 log_error ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12890 log_error ("It will pass over cracked hashes and does not report them as cracked");
12891 log_error ("You are STRONGLY encouraged not to use it");
12892 log_error ("You can use --force to override this but do not post error reports if you do so");
12893
12894 return (-1);
12895 }
12896
12897 if (catalyst_warn == 1)
12898 {
12899 log_error ("");
12900 log_error ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12901 log_error ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12902 log_error ("See oclHashcat's homepage for official supported catalyst drivers");
12903 #ifdef _WIN
12904 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12905 #endif
12906 log_error ("You can use --force to override this but do not post error reports if you do so");
12907
12908 return (-1);
12909 }
12910 }
12911 }
12912 }
12913
12914 /*
12915 * Temporary fix:
12916 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12917 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
12918 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
12919 * Driver / ADL bug?
12920 */
12921
12922 if (vendor_id == VENDOR_ID_AMD)
12923 {
12924 if (powertune_enable == 1)
12925 {
12926 hc_thread_mutex_lock (mux_adl);
12927
12928 for (uint i = 0; i < devices_cnt; i++)
12929 {
12930 if (data.hm_device[i].od_version == 6)
12931 {
12932 // set powertune value only
12933
12934 int powertune_supported = 0;
12935
12936 int ADL_rc = 0;
12937
12938 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
12939 {
12940 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
12941
12942 return (-1);
12943 }
12944
12945 if (powertune_supported != 0)
12946 {
12947 // powertune set
12948 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
12949
12950 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune)) != ADL_OK)
12951 {
12952 log_error ("ERROR: Failed to get current ADL PowerControl settings");
12953
12954 return (-1);
12955 }
12956
12957 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
12958 {
12959 log_error ("ERROR: Failed to set new ADL PowerControl values");
12960
12961 return (-1);
12962 }
12963 }
12964 }
12965 }
12966
12967 hc_thread_mutex_unlock (mux_adl);
12968 }
12969 }
12970
12971 uint kernel_blocks_all = 0;
12972
12973 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12974 {
12975 /**
12976 * host buffer
12977 */
12978
12979 hc_device_param_t *device_param = &data.devices_param[device_id];
12980
12981 /**
12982 * device properties
12983 */
12984
12985 char *device_name_chksum = device_param->device_name_chksum;
12986
12987 uint device_processors = device_param->device_processors;
12988
12989 uint device_processor_cores = device_param->device_processor_cores;
12990
12991 /**
12992 * create context for each device
12993 */
12994
12995 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
12996
12997 /**
12998 * create command-queue
12999 */
13000
13001 // not support with NV
13002 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13003
13004 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13005
13006 /**
13007 * create input buffers on device
13008 */
13009
13010 uint kernel_threads = KERNEL_THREADS;
13011
13012 // bcrypt
13013 if (hash_mode == 3200) kernel_threads = 8;
13014 if (hash_mode == 9000) kernel_threads = 8;
13015
13016 if (device_type == CL_DEVICE_TYPE_CPU)
13017 {
13018 // CPU still need lots of workitems, don't know why...
13019
13020 kernel_accel = (kernel_accel >= 8) ? kernel_accel / 8 : 1;
13021 }
13022
13023 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13024 uint kernel_blocks = kernel_power;
13025
13026 device_param->kernel_threads = kernel_threads;
13027 device_param->kernel_power_user = kernel_power;
13028 device_param->kernel_blocks_user = kernel_blocks;
13029
13030 kernel_blocks_all += kernel_blocks;
13031
13032 uint size_pws = kernel_power * sizeof (pw_t);
13033
13034 uint size_tmps = 4;
13035
13036 switch (hash_mode)
13037 {
13038 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13039 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13040 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13041 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13042 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13043 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13044 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13045 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13046 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13047 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13048 case 6211:
13049 case 6212:
13050 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13051 case 6221:
13052 case 6222:
13053 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13054 case 6231:
13055 case 6232:
13056 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13057 case 6241:
13058 case 6242:
13059 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13060 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13061 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13062 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13063 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13064 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13065 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13066 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13067 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13068 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13069 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13070 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13071 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13072 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13073 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13074 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13075 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13076 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13077 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13078 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13079 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13080 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13081 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13082 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13083 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13084 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13085 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13086 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13087 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13088 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13089 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13090 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13091 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13092 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13093 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13094 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13095 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13096 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13097 };
13098
13099 uint size_hooks = 4;
13100
13101 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13102 {
13103 // insert correct hook size
13104 }
13105
13106 // we can optimize some stuff here...
13107
13108 device_param->size_pws = size_pws;
13109 device_param->size_tmps = size_tmps;
13110 device_param->size_hooks = size_hooks;
13111
13112 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13113 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13114
13115 device_param->size_root_css = size_root_css;
13116 device_param->size_markov_css = size_markov_css;
13117
13118 uint size_results = KERNEL_THREADS * sizeof (uint);
13119
13120 device_param->size_results = size_results;
13121
13122 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13123 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13124
13125 uint size_plains = digests_cnt * sizeof (plain_t);
13126 uint size_salts = salts_cnt * sizeof (salt_t);
13127 uint size_esalts = salts_cnt * esalt_size;
13128
13129 device_param->size_plains = size_plains;
13130 device_param->size_digests = size_digests;
13131 device_param->size_shown = size_shown;
13132 device_param->size_salts = size_salts;
13133
13134 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13135 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13136 uint size_tm = 32 * sizeof (bs_word_t);
13137
13138 uint64_t size_scryptV = 1;
13139
13140 if ((hash_mode == 8900) || (hash_mode == 9300))
13141 {
13142 uint tmto_start = 0;
13143 uint tmto_stop = 10;
13144
13145 if (scrypt_tmto)
13146 {
13147 tmto_start = scrypt_tmto;
13148 }
13149 else
13150 {
13151 // in case the user did not specify the tmto manually
13152 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13153 // but set the lower end only in case the user has a device with too less memory
13154
13155 if (hash_mode == 8900)
13156 {
13157 if (vendor_id == VENDOR_ID_AMD)
13158 {
13159 tmto_start = 1;
13160 }
13161 else if (vendor_id == VENDOR_ID_NV)
13162 {
13163 tmto_start = 3;
13164 }
13165 }
13166 else if (hash_mode == 9300)
13167 {
13168 if (vendor_id == VENDOR_ID_AMD)
13169 {
13170 tmto_start = 3;
13171 }
13172 else if (vendor_id == VENDOR_ID_NV)
13173 {
13174 tmto_start = 5;
13175 }
13176 }
13177 }
13178
13179 if (quiet == 0) log_info ("");
13180
13181 uint shader_per_mp = 1;
13182
13183 if (vendor_id == VENDOR_ID_AMD)
13184 {
13185 shader_per_mp = 8;
13186 }
13187
13188 if (vendor_id == VENDOR_ID_NV)
13189 {
13190 shader_per_mp = 32;
13191 }
13192
13193 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13194 {
13195 // TODO: in theory the following calculation needs to be done per salt, not global
13196 // we assume all hashes have the same scrypt settings
13197
13198 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13199
13200 size_scryptV /= 1 << tmto;
13201
13202 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13203
13204 if (size_scryptV > device_param->device_maxmem_alloc)
13205 {
13206 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13207
13208 continue;
13209 }
13210
13211 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13212 {
13213 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13214 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13215 }
13216
13217 break;
13218 }
13219
13220 if (data.salts_buf[0].scrypt_phy == 0)
13221 {
13222 log_error ("ERROR: can't allocate enough device memory");
13223
13224 return -1;
13225 }
13226
13227 if (quiet == 0) log_info ("");
13228 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13229 }
13230
13231 /**
13232 * default building options
13233 */
13234
13235 char build_opts[1024];
13236
13237 // we don't have sm_* on AMD but it doesn't matter
13238
13239 sprintf (build_opts, "-I%s/ -DVENDOR_ID=%d -DCUDA_ARCH=%d", shared_dir, vendor_id, (device_param->sm_major * 100) + device_param->sm_minor);
13240
13241 /**
13242 * main kernel
13243 */
13244
13245 {
13246 /**
13247 * kernel source filename
13248 */
13249
13250 char source_file[256];
13251
13252 memset (source_file, 0, sizeof (source_file));
13253
13254 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13255
13256 struct stat sst;
13257
13258 if (stat (source_file, &sst) == -1)
13259 {
13260 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13261
13262 return -1;
13263 }
13264
13265 /**
13266 * kernel cached filename
13267 */
13268
13269 char cached_file[256];
13270
13271 memset (cached_file, 0, sizeof (cached_file));
13272
13273 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13274
13275 int cached = 1;
13276
13277 struct stat cst;
13278
13279 if (stat (cached_file, &cst) == -1)
13280 {
13281 cached = 0;
13282 }
13283
13284 /**
13285 * kernel compile or load
13286 */
13287
13288 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13289
13290 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13291
13292 if (force_jit_compilation == 0)
13293 {
13294 if (cached == 0)
13295 {
13296 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13297
13298 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13299
13300 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13301
13302 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13303
13304 size_t binary_size;
13305
13306 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13307
13308 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13309
13310 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13311
13312 writeProgramBin (cached_file, binary, binary_size);
13313
13314 local_free (binary);
13315 }
13316 else
13317 {
13318 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13319
13320 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13321
13322 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13323
13324 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13325 }
13326 }
13327 else
13328 {
13329 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13330
13331 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13332
13333 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13334
13335 if (force_jit_compilation == 1500)
13336 {
13337 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13338 }
13339 else if (force_jit_compilation == 8900)
13340 {
13341 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);
13342 }
13343
13344 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13345 }
13346
13347 local_free (kernel_lengths);
13348 local_free (kernel_sources[0]);
13349 local_free (kernel_sources);
13350
13351 // this is mostly for debug
13352
13353 size_t ret_val_size = 0;
13354
13355 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13356
13357 if (ret_val_size > 2)
13358 {
13359 char *build_log = (char *) mymalloc (ret_val_size + 1);
13360
13361 memset (build_log, 0, ret_val_size + 1);
13362
13363 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13364
13365 puts (build_log);
13366
13367 myfree (build_log);
13368 }
13369 }
13370
13371 /**
13372 * word generator kernel
13373 */
13374
13375 if (attack_mode != ATTACK_MODE_STRAIGHT)
13376 {
13377 /**
13378 * kernel mp source filename
13379 */
13380
13381 char source_file[256];
13382
13383 memset (source_file, 0, sizeof (source_file));
13384
13385 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13386
13387 struct stat sst;
13388
13389 if (stat (source_file, &sst) == -1)
13390 {
13391 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13392
13393 return -1;
13394 }
13395
13396 /**
13397 * kernel mp cached filename
13398 */
13399
13400 char cached_file[256];
13401
13402 memset (cached_file, 0, sizeof (cached_file));
13403
13404 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13405
13406 int cached = 1;
13407
13408 struct stat cst;
13409
13410 if (stat (cached_file, &cst) == -1)
13411 {
13412 cached = 0;
13413 }
13414
13415 /**
13416 * kernel compile or load
13417 */
13418
13419 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13420
13421 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13422
13423 if (cached == 0)
13424 {
13425 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13426
13427 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13428
13429 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13430
13431 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13432
13433 size_t binary_size;
13434
13435 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13436
13437 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13438
13439 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13440
13441 writeProgramBin (cached_file, binary, binary_size);
13442
13443 local_free (binary);
13444 }
13445 else
13446 {
13447 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13448
13449 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13450
13451 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13452
13453 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13454 }
13455
13456 local_free (kernel_lengths);
13457 local_free (kernel_sources[0]);
13458 local_free (kernel_sources);
13459
13460 // this is mostly for debug
13461
13462 size_t ret_val_size = 0;
13463
13464 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13465
13466 if (ret_val_size > 2)
13467 {
13468 char *build_log = (char *) mymalloc (ret_val_size + 1);
13469
13470 memset (build_log, 0, ret_val_size + 1);
13471
13472 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13473
13474 puts (build_log);
13475
13476 myfree (build_log);
13477 }
13478 }
13479
13480 /**
13481 * amplifier kernel
13482 */
13483
13484 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13485 {
13486
13487 }
13488 else
13489 {
13490 /**
13491 * kernel amp source filename
13492 */
13493
13494 char source_file[256];
13495
13496 memset (source_file, 0, sizeof (source_file));
13497
13498 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13499
13500 struct stat sst;
13501
13502 if (stat (source_file, &sst) == -1)
13503 {
13504 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13505
13506 return -1;
13507 }
13508
13509 /**
13510 * kernel amp cached filename
13511 */
13512
13513 char cached_file[256];
13514
13515 memset (cached_file, 0, sizeof (cached_file));
13516
13517 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, vendor_id, cached_file);
13518
13519 int cached = 1;
13520
13521 struct stat cst;
13522
13523 if (stat (cached_file, &cst) == -1)
13524 {
13525 cached = 0;
13526 }
13527
13528 /**
13529 * kernel compile or load
13530 */
13531
13532 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13533
13534 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13535
13536 if (cached == 0)
13537 {
13538 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13539
13540 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13541
13542 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13543
13544 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13545
13546 size_t binary_size;
13547
13548 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13549
13550 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13551
13552 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13553
13554 writeProgramBin (cached_file, binary, binary_size);
13555
13556 local_free (binary);
13557 }
13558 else
13559 {
13560 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13561
13562 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13563
13564 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13565
13566 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13567 }
13568
13569 local_free (kernel_lengths);
13570 local_free (kernel_sources[0]);
13571 local_free (kernel_sources);
13572
13573 // this is mostly for debug
13574
13575 size_t ret_val_size = 0;
13576
13577 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13578
13579 if (ret_val_size > 2)
13580 {
13581 char *build_log = (char *) mymalloc (ret_val_size + 1);
13582
13583 memset (build_log, 0, ret_val_size + 1);
13584
13585 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13586
13587 puts (build_log);
13588
13589 myfree (build_log);
13590 }
13591 }
13592
13593 /**
13594 * global buffers
13595 */
13596
13597 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13598 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13599 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13600 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13601 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13602 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13603 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13604 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13605 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13606 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13607 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13608 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13609 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13610 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13611 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13612 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13613 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13614 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13615
13616 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13617 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13618 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13619 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13620 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13621 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13622 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13623 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13624 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13625 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13626 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13627
13628 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13629 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13630 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13631 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13632 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13633 run_kernel_bzero (device_param, device_param->d_result, size_results);
13634
13635 /**
13636 * special buffers
13637 */
13638
13639 if (attack_kern == ATTACK_KERN_STRAIGHT)
13640 {
13641 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13642 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13643
13644 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13645
13646 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13647 }
13648 else if (attack_kern == ATTACK_KERN_COMBI)
13649 {
13650 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13651 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13652 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13653 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13654
13655 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13656 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13657 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13658 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13659 }
13660 else if (attack_kern == ATTACK_KERN_BF)
13661 {
13662 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13663 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13664 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13665 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13666 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13667
13668 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13669 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13670 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13671 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13672 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13673 }
13674
13675 if (size_esalts)
13676 {
13677 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13678
13679 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13680 }
13681
13682 /**
13683 * main host data
13684 */
13685
13686 uint *result = (uint *) mymalloc (size_results);
13687
13688 memset (result, 0, size_results);
13689
13690 device_param->result = result;
13691
13692 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13693
13694 memset (pws_buf, 0, size_pws);
13695
13696 device_param->pws_buf = pws_buf;
13697
13698 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13699
13700 for (int i = 0; i < 64; i++)
13701 {
13702 pw_caches[i].pw_buf.pw_len = i;
13703 pw_caches[i].cnt = 0;
13704 }
13705
13706 device_param->pw_caches = pw_caches;
13707
13708 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13709
13710 device_param->combs_buf = combs_buf;
13711
13712 void *hooks_buf = mymalloc (size_hooks);
13713
13714 device_param->hooks_buf = hooks_buf;
13715
13716 device_param->pw_transpose = pw_transpose_to_hi1;
13717 device_param->pw_add = pw_add_to_hc1;
13718
13719 /**
13720 * kernel args
13721 */
13722
13723 device_param->kernel_params_buf32[21] = bitmap_mask;
13724 device_param->kernel_params_buf32[22] = bitmap_shift1;
13725 device_param->kernel_params_buf32[23] = bitmap_shift2;
13726 device_param->kernel_params_buf32[24] = 0; // salt_pos
13727 device_param->kernel_params_buf32[25] = 0; // loop_pos
13728 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13729 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13730 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13731 device_param->kernel_params_buf32[29] = 0; // digests_offset
13732 device_param->kernel_params_buf32[30] = 0; // combs_mode
13733 device_param->kernel_params_buf32[31] = 0; // gid_max
13734
13735 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13736 ? &device_param->d_pws_buf
13737 : &device_param->d_pws_amp_buf;
13738 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13739 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13740 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13741 device_param->kernel_params[ 4] = &device_param->d_tmps;
13742 device_param->kernel_params[ 5] = &device_param->d_hooks;
13743 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13744 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13745 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13746 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13747 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13748 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13749 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13750 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13751 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13752 device_param->kernel_params[15] = &device_param->d_digests_buf;
13753 device_param->kernel_params[16] = &device_param->d_digests_shown;
13754 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13755 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13756 device_param->kernel_params[19] = &device_param->d_result;
13757 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13758 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13759 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13760 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13761 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13762 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13763 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13764 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13765 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13766 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13767 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13768 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13769
13770 device_param->kernel_params_mp_buf64[3] = 0;
13771 device_param->kernel_params_mp_buf32[4] = 0;
13772 device_param->kernel_params_mp_buf32[5] = 0;
13773 device_param->kernel_params_mp_buf32[6] = 0;
13774 device_param->kernel_params_mp_buf32[7] = 0;
13775 device_param->kernel_params_mp_buf32[8] = 0;
13776
13777 device_param->kernel_params_mp[0] = NULL;
13778 device_param->kernel_params_mp[1] = NULL;
13779 device_param->kernel_params_mp[2] = NULL;
13780 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13781 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13782 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13783 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13784 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13785 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13786
13787 device_param->kernel_params_mp_l_buf64[3] = 0;
13788 device_param->kernel_params_mp_l_buf32[4] = 0;
13789 device_param->kernel_params_mp_l_buf32[5] = 0;
13790 device_param->kernel_params_mp_l_buf32[6] = 0;
13791 device_param->kernel_params_mp_l_buf32[7] = 0;
13792 device_param->kernel_params_mp_l_buf32[8] = 0;
13793 device_param->kernel_params_mp_l_buf32[9] = 0;
13794
13795 device_param->kernel_params_mp_l[0] = NULL;
13796 device_param->kernel_params_mp_l[1] = NULL;
13797 device_param->kernel_params_mp_l[2] = NULL;
13798 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13799 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13800 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13801 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13802 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13803 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13804 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13805
13806 device_param->kernel_params_mp_r_buf64[3] = 0;
13807 device_param->kernel_params_mp_r_buf32[4] = 0;
13808 device_param->kernel_params_mp_r_buf32[5] = 0;
13809 device_param->kernel_params_mp_r_buf32[6] = 0;
13810 device_param->kernel_params_mp_r_buf32[7] = 0;
13811 device_param->kernel_params_mp_r_buf32[8] = 0;
13812
13813 device_param->kernel_params_mp_r[0] = NULL;
13814 device_param->kernel_params_mp_r[1] = NULL;
13815 device_param->kernel_params_mp_r[2] = NULL;
13816 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
13817 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
13818 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
13819 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
13820 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
13821 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
13822
13823 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
13824 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
13825
13826 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
13827 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
13828 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
13829 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
13830 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
13831 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
13832 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
13833
13834 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
13835
13836 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
13837 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
13838
13839 /**
13840 * kernel name
13841 */
13842
13843 char kernel_name[64];
13844
13845 memset (kernel_name, 0, sizeof (kernel_name));
13846
13847 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13848 {
13849 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13850 {
13851 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
13852
13853 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13854
13855 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
13856
13857 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13858
13859 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
13860
13861 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13862 }
13863 else
13864 {
13865 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
13866
13867 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13868
13869 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
13870
13871 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13872
13873 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
13874
13875 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13876 }
13877
13878 if (data.attack_mode == ATTACK_MODE_BF)
13879 {
13880 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13881 {
13882 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
13883
13884 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
13885
13886 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
13887
13888 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
13889 }
13890 }
13891 }
13892 else
13893 {
13894 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
13895
13896 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13897
13898 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
13899
13900 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13901
13902 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
13903
13904 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13905
13906 if (opts_type & OPTS_TYPE_HOOK12)
13907 {
13908 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
13909
13910 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
13911 }
13912
13913 if (opts_type & OPTS_TYPE_HOOK23)
13914 {
13915 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
13916
13917 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
13918 }
13919 }
13920
13921 for (uint i = 0; i <= 20; i++)
13922 {
13923 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
13924 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
13925 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
13926
13927 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
13928 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
13929 }
13930
13931 for (uint i = 21; i <= 31; i++)
13932 {
13933 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
13934 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
13935 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
13936
13937 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
13938 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
13939 }
13940
13941 if (attack_mode == ATTACK_MODE_BF)
13942 {
13943 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
13944 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
13945
13946 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13947 {
13948 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
13949
13950 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
13951 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
13952 }
13953 }
13954 else if (attack_mode == ATTACK_MODE_HYBRID1)
13955 {
13956 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13957 }
13958 else if (attack_mode == ATTACK_MODE_HYBRID2)
13959 {
13960 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13961 }
13962
13963 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13964 {
13965 // nothing to do
13966 }
13967 else
13968 {
13969 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
13970 }
13971
13972 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13973 {
13974 // nothing to do
13975 }
13976 else
13977 {
13978 for (uint i = 0; i < 5; i++)
13979 {
13980 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
13981 }
13982
13983 for (uint i = 5; i < 7; i++)
13984 {
13985 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
13986 }
13987 }
13988
13989 /**
13990 * Store initial fanspeed if gpu_temp_retain is enabled
13991 */
13992
13993 int gpu_temp_retain_set = 0;
13994
13995 if (gpu_temp_disable == 0)
13996 {
13997 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
13998 {
13999 hc_thread_mutex_lock (mux_adl);
14000
14001 if (data.hm_device[device_id].fan_supported == 1)
14002 {
14003 if (gpu_temp_retain_chgd == 0)
14004 {
14005 uint cur_temp = 0;
14006 uint default_temp = 0;
14007
14008 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);
14009
14010 if (ADL_rc == ADL_OK)
14011 {
14012 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14013
14014 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14015
14016 // special case with multi gpu setups: always use minimum retain
14017
14018 if (gpu_temp_retain_set == 0)
14019 {
14020 gpu_temp_retain = gpu_temp_retain_target;
14021 gpu_temp_retain_set = 1;
14022 }
14023 else
14024 {
14025 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14026 }
14027
14028 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14029 }
14030 }
14031
14032 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14033
14034 temp_retain_fanspeed_value[device_id] = fan_speed;
14035
14036 if (fan_speed == -1)
14037 {
14038 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14039
14040 temp_retain_fanspeed_value[device_id] = 0;
14041 }
14042 }
14043
14044 hc_thread_mutex_unlock (mux_adl);
14045 }
14046 }
14047
14048 /**
14049 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14050 */
14051
14052 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14053 {
14054 hc_thread_mutex_lock (mux_adl);
14055
14056 if (data.hm_device[device_id].od_version == 6)
14057 {
14058 int ADL_rc;
14059
14060 // check powertune capabilities first, if not available then skip device
14061
14062 int powertune_supported = 0;
14063
14064 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14065 {
14066 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14067
14068 return (-1);
14069 }
14070
14071 if (powertune_supported != 0)
14072 {
14073 // powercontrol settings
14074
14075 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14076
14077 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14078 {
14079 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14080 }
14081
14082 if (ADL_rc != ADL_OK)
14083 {
14084 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14085
14086 return (-1);
14087 }
14088
14089 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14090 {
14091 log_error ("ERROR: Failed to set new ADL PowerControl values");
14092
14093 return (-1);
14094 }
14095
14096 // clocks
14097
14098 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14099
14100 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14101
14102 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)
14103 {
14104 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14105
14106 return (-1);
14107 }
14108
14109 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14110
14111 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14112
14113 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14114 {
14115 log_error ("ERROR: Failed to get ADL device capabilities");
14116
14117 return (-1);
14118 }
14119
14120 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14121 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14122
14123 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14124 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14125
14126 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14127 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14128
14129 // warning if profile has to low max values
14130
14131 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14132 {
14133 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14134 }
14135
14136 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14137 {
14138 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14139 }
14140
14141 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14142
14143 performance_state->iNumberOfPerformanceLevels = 2;
14144
14145 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14146 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14147 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14148 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14149
14150 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)
14151 {
14152 log_info ("ERROR: Failed to set ADL performance state");
14153
14154 return (-1);
14155 }
14156
14157 local_free (performance_state);
14158 }
14159 }
14160
14161 hc_thread_mutex_unlock (mux_adl);
14162 }
14163 }
14164
14165 data.kernel_blocks_all = kernel_blocks_all;
14166
14167 if (data.quiet == 0) log_info ("");
14168
14169 /**
14170 * Inform user which algorithm is checked and at which workload setting
14171 */
14172
14173 if (benchmark == 1)
14174 {
14175 quiet = 0;
14176
14177 data.quiet = quiet;
14178
14179 char *hash_type = strhashtype (data.hash_mode); // not a bug
14180
14181 log_info ("Hashtype: %s", hash_type);
14182 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14183 log_info ("");
14184 }
14185
14186 /**
14187 * keep track of the progress
14188 */
14189
14190 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14191 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14192 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14193
14194 /**
14195 * open filehandles
14196 */
14197
14198 #if _WIN
14199 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14200 {
14201 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14202
14203 return (-1);
14204 }
14205
14206 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14207 {
14208 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14209
14210 return (-1);
14211 }
14212
14213 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14214 {
14215 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14216
14217 return (-1);
14218 }
14219 #endif
14220
14221 /**
14222 * dictionary pad
14223 */
14224
14225 segment_size *= (1024 * 1024);
14226
14227 data.segment_size = segment_size;
14228
14229 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14230
14231 wl_data->buf = (char *) mymalloc (segment_size);
14232 wl_data->avail = segment_size;
14233 wl_data->incr = segment_size;
14234 wl_data->cnt = 0;
14235 wl_data->pos = 0;
14236
14237 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14238
14239 data.wordlist_mode = wordlist_mode;
14240
14241 cs_t *css_buf = NULL;
14242 uint css_cnt = 0;
14243 uint dictcnt = 0;
14244 uint maskcnt = 1;
14245 char **masks = NULL;
14246 char **dictfiles = NULL;
14247
14248 uint mask_from_file = 0;
14249
14250 if (attack_mode == ATTACK_MODE_STRAIGHT)
14251 {
14252 if (wordlist_mode == WL_MODE_FILE)
14253 {
14254 int wls_left = myargc - (optind + 1);
14255
14256 for (int i = 0; i < wls_left; i++)
14257 {
14258 char *l0_filename = myargv[optind + 1 + i];
14259
14260 struct stat l0_stat;
14261
14262 if (stat (l0_filename, &l0_stat) == -1)
14263 {
14264 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14265
14266 return (-1);
14267 }
14268
14269 uint is_dir = S_ISDIR (l0_stat.st_mode);
14270
14271 if (is_dir == 0)
14272 {
14273 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14274
14275 dictcnt++;
14276
14277 dictfiles[dictcnt - 1] = l0_filename;
14278 }
14279 else
14280 {
14281 // do not allow --keyspace w/ a directory
14282
14283 if (keyspace == 1)
14284 {
14285 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14286
14287 return (-1);
14288 }
14289
14290 char **dictionary_files = NULL;
14291
14292 dictionary_files = scan_directory (l0_filename);
14293
14294 if (dictionary_files != NULL)
14295 {
14296 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14297
14298 for (int d = 0; dictionary_files[d] != NULL; d++)
14299 {
14300 char *l1_filename = dictionary_files[d];
14301
14302 struct stat l1_stat;
14303
14304 if (stat (l1_filename, &l1_stat) == -1)
14305 {
14306 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14307
14308 return (-1);
14309 }
14310
14311 if (S_ISREG (l1_stat.st_mode))
14312 {
14313 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14314
14315 dictcnt++;
14316
14317 dictfiles[dictcnt - 1] = strdup (l1_filename);
14318 }
14319 }
14320 }
14321
14322 local_free (dictionary_files);
14323 }
14324 }
14325
14326 if (dictcnt < 1)
14327 {
14328 log_error ("ERROR: No usable dictionary file found.");
14329
14330 return (-1);
14331 }
14332 }
14333 else if (wordlist_mode == WL_MODE_STDIN)
14334 {
14335 dictcnt = 1;
14336 }
14337 }
14338 else if (attack_mode == ATTACK_MODE_COMBI)
14339 {
14340 // display
14341
14342 char *dictfile1 = myargv[optind + 1 + 0];
14343 char *dictfile2 = myargv[optind + 1 + 1];
14344
14345 // find the bigger dictionary and use as base
14346
14347 FILE *fp1;
14348 FILE *fp2;
14349
14350 struct stat tmp_stat;
14351
14352 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14353 {
14354 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14355
14356 return (-1);
14357 }
14358
14359 if (stat (dictfile1, &tmp_stat) == -1)
14360 {
14361 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14362
14363 fclose (fp1);
14364
14365 return (-1);
14366 }
14367
14368 if (S_ISDIR (tmp_stat.st_mode))
14369 {
14370 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14371
14372 fclose (fp1);
14373
14374 return (-1);
14375 }
14376
14377 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14378 {
14379 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14380
14381 fclose (fp1);
14382
14383 return (-1);
14384 }
14385
14386 if (stat (dictfile2, &tmp_stat) == -1)
14387 {
14388 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14389
14390 fclose (fp1);
14391 fclose (fp2);
14392
14393 return (-1);
14394 }
14395
14396 if (S_ISDIR (tmp_stat.st_mode))
14397 {
14398 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14399
14400 fclose (fp1);
14401 fclose (fp2);
14402
14403 return (-1);
14404 }
14405
14406 data.combs_cnt = 1;
14407
14408 data.quiet = 1;
14409
14410 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14411
14412 data.quiet = quiet;
14413
14414 if (words1_cnt == 0)
14415 {
14416 log_error ("ERROR: %s: empty file", dictfile1);
14417
14418 fclose (fp1);
14419 fclose (fp2);
14420
14421 return (-1);
14422 }
14423
14424 data.combs_cnt = 1;
14425
14426 data.quiet = 1;
14427
14428 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14429
14430 data.quiet = quiet;
14431
14432 if (words2_cnt == 0)
14433 {
14434 log_error ("ERROR: %s: empty file", dictfile2);
14435
14436 fclose (fp1);
14437 fclose (fp2);
14438
14439 return (-1);
14440 }
14441
14442 fclose (fp1);
14443 fclose (fp2);
14444
14445 data.dictfile = dictfile1;
14446 data.dictfile2 = dictfile2;
14447
14448 if (words1_cnt >= words2_cnt)
14449 {
14450 data.combs_cnt = words2_cnt;
14451 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14452
14453 dictfiles = &data.dictfile;
14454
14455 dictcnt = 1;
14456 }
14457 else
14458 {
14459 data.combs_cnt = words1_cnt;
14460 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14461
14462 dictfiles = &data.dictfile2;
14463
14464 dictcnt = 1;
14465
14466 // we also have to switch wordlist related rules!
14467
14468 char *tmpc = data.rule_buf_l;
14469
14470 data.rule_buf_l = data.rule_buf_r;
14471 data.rule_buf_r = tmpc;
14472
14473 int tmpi = data.rule_len_l;
14474
14475 data.rule_len_l = data.rule_len_r;
14476 data.rule_len_r = tmpi;
14477 }
14478 }
14479 else if (attack_mode == ATTACK_MODE_BF)
14480 {
14481 char *mask = NULL;
14482
14483 maskcnt = 0;
14484
14485 if (benchmark == 0)
14486 {
14487 mask = myargv[optind + 1];
14488
14489 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14490
14491 if ((optind + 2) <= myargc)
14492 {
14493 struct stat file_stat;
14494
14495 if (stat (mask, &file_stat) == -1)
14496 {
14497 maskcnt = 1;
14498
14499 masks[maskcnt - 1] = mystrdup (mask);
14500 }
14501 else
14502 {
14503 int wls_left = myargc - (optind + 1);
14504
14505 uint masks_avail = INCR_MASKS;
14506
14507 for (int i = 0; i < wls_left; i++)
14508 {
14509 if (i != 0)
14510 {
14511 mask = myargv[optind + 1 + i];
14512
14513 if (stat (mask, &file_stat) == -1)
14514 {
14515 log_error ("ERROR: %s: %s", mask, strerror (errno));
14516
14517 return (-1);
14518 }
14519 }
14520
14521 uint is_file = S_ISREG (file_stat.st_mode);
14522
14523 if (is_file == 1)
14524 {
14525 FILE *mask_fp;
14526
14527 if ((mask_fp = fopen (mask, "r")) == NULL)
14528 {
14529 log_error ("ERROR: %s: %s", mask, strerror (errno));
14530
14531 return (-1);
14532 }
14533
14534 char line_buf[BUFSIZ];
14535
14536 while (!feof (mask_fp))
14537 {
14538 memset (line_buf, 0, BUFSIZ);
14539
14540 int line_len = fgetl (mask_fp, line_buf);
14541
14542 if (line_len == 0) continue;
14543
14544 if (line_buf[0] == '#') continue;
14545
14546 if (masks_avail == maskcnt)
14547 {
14548 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14549
14550 masks_avail += INCR_MASKS;
14551 }
14552
14553 masks[maskcnt] = mystrdup (line_buf);
14554
14555 maskcnt++;
14556 }
14557
14558 fclose (mask_fp);
14559 }
14560 else
14561 {
14562 log_error ("ERROR: %s: unsupported file-type", mask);
14563
14564 return (-1);
14565 }
14566 }
14567
14568 mask_from_file = 1;
14569 }
14570 }
14571 else
14572 {
14573 custom_charset_1 = (char *) "?l?d?u";
14574 custom_charset_2 = (char *) "?l?d";
14575 custom_charset_3 = (char *) "?l?d*!$@_";
14576
14577 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14578 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14579 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14580
14581 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14582
14583 wordlist_mode = WL_MODE_MASK;
14584
14585 data.wordlist_mode = wordlist_mode;
14586
14587 increment = 1;
14588
14589 maskcnt = 1;
14590 }
14591 }
14592 else
14593 {
14594 /**
14595 * generate full masks and charsets
14596 */
14597
14598 masks = (char **) mymalloc (sizeof (char *));
14599
14600 switch (hash_mode)
14601 {
14602 case 1731: pw_min = 5;
14603 pw_max = 5;
14604 mask = mystrdup ("?b?b?b?b?b");
14605 break;
14606 case 12500: pw_min = 5;
14607 pw_max = 5;
14608 mask = mystrdup ("?b?b?b?b?b");
14609 break;
14610 default: pw_min = 7;
14611 pw_max = 7;
14612 mask = mystrdup ("?b?b?b?b?b?b?b");
14613 break;
14614 }
14615
14616 maskcnt = 1;
14617
14618 masks[maskcnt - 1] = mystrdup (mask);
14619
14620 wordlist_mode = WL_MODE_MASK;
14621
14622 data.wordlist_mode = wordlist_mode;
14623
14624 increment = 1;
14625 }
14626
14627 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14628
14629 if (increment)
14630 {
14631 if (increment_min > pw_min) pw_min = increment_min;
14632
14633 if (increment_max < pw_max) pw_max = increment_max;
14634 }
14635 }
14636 else if (attack_mode == ATTACK_MODE_HYBRID1)
14637 {
14638 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14639
14640 // display
14641
14642 char *mask = myargv[myargc - 1];
14643
14644 maskcnt = 0;
14645
14646 masks = (char **) mymalloc (1 * sizeof (char *));
14647
14648 // mod
14649
14650 struct stat file_stat;
14651
14652 if (stat (mask, &file_stat) == -1)
14653 {
14654 maskcnt = 1;
14655
14656 masks[maskcnt - 1] = mystrdup (mask);
14657 }
14658 else
14659 {
14660 uint is_file = S_ISREG (file_stat.st_mode);
14661
14662 if (is_file == 1)
14663 {
14664 FILE *mask_fp;
14665
14666 if ((mask_fp = fopen (mask, "r")) == NULL)
14667 {
14668 log_error ("ERROR: %s: %s", mask, strerror (errno));
14669
14670 return (-1);
14671 }
14672
14673 char line_buf[BUFSIZ];
14674
14675 uint masks_avail = 1;
14676
14677 while (!feof (mask_fp))
14678 {
14679 memset (line_buf, 0, BUFSIZ);
14680
14681 int line_len = fgetl (mask_fp, line_buf);
14682
14683 if (line_len == 0) continue;
14684
14685 if (line_buf[0] == '#') continue;
14686
14687 if (masks_avail == maskcnt)
14688 {
14689 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14690
14691 masks_avail += INCR_MASKS;
14692 }
14693
14694 masks[maskcnt] = mystrdup (line_buf);
14695
14696 maskcnt++;
14697 }
14698
14699 fclose (mask_fp);
14700
14701 mask_from_file = 1;
14702 }
14703 else
14704 {
14705 maskcnt = 1;
14706
14707 masks[maskcnt - 1] = mystrdup (mask);
14708 }
14709 }
14710
14711 // base
14712
14713 int wls_left = myargc - (optind + 2);
14714
14715 for (int i = 0; i < wls_left; i++)
14716 {
14717 char *filename = myargv[optind + 1 + i];
14718
14719 struct stat file_stat;
14720
14721 if (stat (filename, &file_stat) == -1)
14722 {
14723 log_error ("ERROR: %s: %s", filename, strerror (errno));
14724
14725 return (-1);
14726 }
14727
14728 uint is_dir = S_ISDIR (file_stat.st_mode);
14729
14730 if (is_dir == 0)
14731 {
14732 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14733
14734 dictcnt++;
14735
14736 dictfiles[dictcnt - 1] = filename;
14737 }
14738 else
14739 {
14740 // do not allow --keyspace w/ a directory
14741
14742 if (keyspace == 1)
14743 {
14744 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14745
14746 return (-1);
14747 }
14748
14749 char **dictionary_files = NULL;
14750
14751 dictionary_files = scan_directory (filename);
14752
14753 if (dictionary_files != NULL)
14754 {
14755 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14756
14757 for (int d = 0; dictionary_files[d] != NULL; d++)
14758 {
14759 char *l1_filename = dictionary_files[d];
14760
14761 struct stat l1_stat;
14762
14763 if (stat (l1_filename, &l1_stat) == -1)
14764 {
14765 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14766
14767 return (-1);
14768 }
14769
14770 if (S_ISREG (l1_stat.st_mode))
14771 {
14772 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14773
14774 dictcnt++;
14775
14776 dictfiles[dictcnt - 1] = strdup (l1_filename);
14777 }
14778 }
14779 }
14780
14781 local_free (dictionary_files);
14782 }
14783 }
14784
14785 if (dictcnt < 1)
14786 {
14787 log_error ("ERROR: No usable dictionary file found.");
14788
14789 return (-1);
14790 }
14791
14792 if (increment)
14793 {
14794 maskcnt = 0;
14795
14796 uint mask_min = increment_min; // we can't reject smaller masks here
14797 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14798
14799 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14800 {
14801 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14802
14803 if (cur_mask == NULL) break;
14804
14805 masks[maskcnt] = cur_mask;
14806
14807 maskcnt++;
14808
14809 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14810 }
14811 }
14812 }
14813 else if (attack_mode == ATTACK_MODE_HYBRID2)
14814 {
14815 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14816
14817 // display
14818
14819 char *mask = myargv[optind + 1 + 0];
14820
14821 maskcnt = 0;
14822
14823 masks = (char **) mymalloc (1 * sizeof (char *));
14824
14825 // mod
14826
14827 struct stat file_stat;
14828
14829 if (stat (mask, &file_stat) == -1)
14830 {
14831 maskcnt = 1;
14832
14833 masks[maskcnt - 1] = mystrdup (mask);
14834 }
14835 else
14836 {
14837 uint is_file = S_ISREG (file_stat.st_mode);
14838
14839 if (is_file == 1)
14840 {
14841 FILE *mask_fp;
14842
14843 if ((mask_fp = fopen (mask, "r")) == NULL)
14844 {
14845 log_error ("ERROR: %s: %s", mask, strerror (errno));
14846
14847 return (-1);
14848 }
14849
14850 char line_buf[BUFSIZ];
14851
14852 uint masks_avail = 1;
14853
14854 while (!feof (mask_fp))
14855 {
14856 memset (line_buf, 0, BUFSIZ);
14857
14858 int line_len = fgetl (mask_fp, line_buf);
14859
14860 if (line_len == 0) continue;
14861
14862 if (line_buf[0] == '#') continue;
14863
14864 if (masks_avail == maskcnt)
14865 {
14866 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14867
14868 masks_avail += INCR_MASKS;
14869 }
14870
14871 masks[maskcnt] = mystrdup (line_buf);
14872
14873 maskcnt++;
14874 }
14875
14876 fclose (mask_fp);
14877
14878 mask_from_file = 1;
14879 }
14880 else
14881 {
14882 maskcnt = 1;
14883
14884 masks[maskcnt - 1] = mystrdup (mask);
14885 }
14886 }
14887
14888 // base
14889
14890 int wls_left = myargc - (optind + 2);
14891
14892 for (int i = 0; i < wls_left; i++)
14893 {
14894 char *filename = myargv[optind + 2 + i];
14895
14896 struct stat file_stat;
14897
14898 if (stat (filename, &file_stat) == -1)
14899 {
14900 log_error ("ERROR: %s: %s", filename, strerror (errno));
14901
14902 return (-1);
14903 }
14904
14905 uint is_dir = S_ISDIR (file_stat.st_mode);
14906
14907 if (is_dir == 0)
14908 {
14909 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14910
14911 dictcnt++;
14912
14913 dictfiles[dictcnt - 1] = filename;
14914 }
14915 else
14916 {
14917 // do not allow --keyspace w/ a directory
14918
14919 if (keyspace == 1)
14920 {
14921 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14922
14923 return (-1);
14924 }
14925
14926 char **dictionary_files = NULL;
14927
14928 dictionary_files = scan_directory (filename);
14929
14930 if (dictionary_files != NULL)
14931 {
14932 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14933
14934 for (int d = 0; dictionary_files[d] != NULL; d++)
14935 {
14936 char *l1_filename = dictionary_files[d];
14937
14938 struct stat l1_stat;
14939
14940 if (stat (l1_filename, &l1_stat) == -1)
14941 {
14942 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14943
14944 return (-1);
14945 }
14946
14947 if (S_ISREG (l1_stat.st_mode))
14948 {
14949 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14950
14951 dictcnt++;
14952
14953 dictfiles[dictcnt - 1] = strdup (l1_filename);
14954 }
14955 }
14956 }
14957
14958 local_free (dictionary_files);
14959 }
14960 }
14961
14962 if (dictcnt < 1)
14963 {
14964 log_error ("ERROR: No usable dictionary file found.");
14965
14966 return (-1);
14967 }
14968
14969 if (increment)
14970 {
14971 maskcnt = 0;
14972
14973 uint mask_min = increment_min; // we can't reject smaller masks here
14974 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14975
14976 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14977 {
14978 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14979
14980 if (cur_mask == NULL) break;
14981
14982 masks[maskcnt] = cur_mask;
14983
14984 maskcnt++;
14985
14986 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14987 }
14988 }
14989 }
14990
14991 data.pw_min = pw_min;
14992 data.pw_max = pw_max;
14993
14994 /**
14995 * weak hash check
14996 */
14997
14998 if (weak_hash_threshold >= salts_cnt)
14999 {
15000 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15001
15002 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15003 {
15004 weak_hash_check (&data.devices_param[0], salt_pos, kernel_loops);
15005 }
15006 }
15007
15008 // Display hack, guarantee that there is at least one \r before real start
15009
15010 if (data.quiet == 0) log_info_nn ("");
15011
15012 /**
15013 * status and monitor threads
15014 */
15015
15016 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15017
15018 hc_thread_t i_thread = 0;
15019
15020 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15021 {
15022 hc_thread_create (i_thread, thread_keypress, &benchmark);
15023 }
15024
15025 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15026
15027 uint ni_threads_cnt = 0;
15028
15029 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15030
15031 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15032
15033 ni_threads_cnt++;
15034
15035 /**
15036 * Outfile remove
15037 */
15038
15039 if (keyspace == 0)
15040 {
15041 if (outfile_check_timer != 0)
15042 {
15043 if (data.outfile_check_directory != NULL)
15044 {
15045 if ((hash_mode != 5200) &&
15046 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15047 (hash_mode != 9000))
15048 {
15049 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15050
15051 ni_threads_cnt++;
15052 }
15053 else
15054 {
15055 outfile_check_timer = 0;
15056 }
15057 }
15058 else
15059 {
15060 outfile_check_timer = 0;
15061 }
15062 }
15063 }
15064
15065 /**
15066 * Inform the user if we got some hashes remove because of the pot file remove feature
15067 */
15068
15069 if (data.quiet == 0)
15070 {
15071 if (potfile_remove_cracks > 0)
15072 {
15073 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15074 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15075 }
15076 }
15077
15078 data.outfile_check_timer = outfile_check_timer;
15079
15080 /**
15081 * main loop
15082 */
15083
15084 char **induction_dictionaries = NULL;
15085
15086 int induction_dictionaries_cnt = 0;
15087
15088 hcstat_table_t *root_table_buf = NULL;
15089 hcstat_table_t *markov_table_buf = NULL;
15090
15091 uint initial_restore_done = 0;
15092
15093 data.maskcnt = maskcnt;
15094
15095 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15096 {
15097 if (data.devices_status == STATUS_CRACKED) break;
15098
15099 data.devices_status = STATUS_INIT;
15100
15101 if (maskpos > rd->maskpos)
15102 {
15103 rd->dictpos = 0;
15104 }
15105
15106 rd->maskpos = maskpos;
15107 data.maskpos = maskpos;
15108
15109 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15110 {
15111 char *mask = masks[maskpos];
15112
15113 if (mask_from_file == 1)
15114 {
15115 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15116
15117 char *str_ptr;
15118 uint str_pos;
15119
15120 uint mask_offset = 0;
15121
15122 uint separator_cnt;
15123
15124 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15125 {
15126 str_ptr = strstr (mask + mask_offset, ",");
15127
15128 if (str_ptr == NULL) break;
15129
15130 str_pos = str_ptr - mask;
15131
15132 // escaped separator, i.e. "\,"
15133
15134 if (str_pos > 0)
15135 {
15136 if (mask[str_pos - 1] == '\\')
15137 {
15138 separator_cnt --;
15139
15140 mask_offset = str_pos + 1;
15141
15142 continue;
15143 }
15144 }
15145
15146 // reset the offset
15147
15148 mask_offset = 0;
15149
15150 mask[str_pos] = '\0';
15151
15152 switch (separator_cnt)
15153 {
15154 case 0:
15155 mp_reset_usr (mp_usr, 0);
15156
15157 custom_charset_1 = mask;
15158 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15159 break;
15160
15161 case 1:
15162 mp_reset_usr (mp_usr, 1);
15163
15164 custom_charset_2 = mask;
15165 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15166 break;
15167
15168 case 2:
15169 mp_reset_usr (mp_usr, 2);
15170
15171 custom_charset_3 = mask;
15172 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15173 break;
15174
15175 case 3:
15176 mp_reset_usr (mp_usr, 3);
15177
15178 custom_charset_4 = mask;
15179 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15180 break;
15181 }
15182
15183 mask = mask + str_pos + 1;
15184 }
15185 }
15186
15187 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15188 {
15189 if (maskpos > 0)
15190 {
15191 local_free (css_buf);
15192 local_free (data.root_css_buf);
15193 local_free (data.markov_css_buf);
15194
15195 local_free (masks[maskpos - 1]);
15196 }
15197
15198 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15199
15200 data.mask = mask;
15201 data.css_cnt = css_cnt;
15202 data.css_buf = css_buf;
15203
15204 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15205
15206 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15207
15208 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15209
15210 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15211 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15212
15213 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15214
15215 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15216
15217 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15218 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15219
15220 data.root_css_buf = root_css_buf;
15221 data.markov_css_buf = markov_css_buf;
15222
15223 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15224
15225 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15226
15227 local_free (root_table_buf);
15228 local_free (markov_table_buf);
15229
15230 // args
15231
15232 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15233 {
15234 hc_device_param_t *device_param = &data.devices_param[device_id];
15235
15236 device_param->kernel_params_mp[0] = &device_param->d_combs;
15237 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15238 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15239
15240 device_param->kernel_params_mp_buf64[3] = 0;
15241 device_param->kernel_params_mp_buf32[4] = css_cnt;
15242 device_param->kernel_params_mp_buf32[5] = 0;
15243 device_param->kernel_params_mp_buf32[6] = 0;
15244 device_param->kernel_params_mp_buf32[7] = 0;
15245
15246 if (attack_mode == ATTACK_MODE_HYBRID1)
15247 {
15248 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15249 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15250 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15251 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15252 }
15253 else if (attack_mode == ATTACK_MODE_HYBRID2)
15254 {
15255 device_param->kernel_params_mp_buf32[5] = 0;
15256 device_param->kernel_params_mp_buf32[6] = 0;
15257 device_param->kernel_params_mp_buf32[7] = 0;
15258 }
15259
15260 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15261 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15262 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15263
15264 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);
15265 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);
15266 }
15267 }
15268 else if (attack_mode == ATTACK_MODE_BF)
15269 {
15270 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15271
15272 if (increment)
15273 {
15274 for (uint i = 0; i < dictcnt; i++)
15275 {
15276 local_free (dictfiles[i]);
15277 }
15278
15279 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15280 {
15281 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15282
15283 if (l1_filename == NULL) break;
15284
15285 dictcnt++;
15286
15287 dictfiles[dictcnt - 1] = l1_filename;
15288 }
15289 }
15290 else
15291 {
15292 dictcnt++;
15293
15294 dictfiles[dictcnt - 1] = mask;
15295 }
15296
15297 if (dictcnt == 0)
15298 {
15299 log_error ("ERROR: Mask is too small");
15300
15301 return (-1);
15302 }
15303 }
15304 }
15305
15306 free (induction_dictionaries);
15307
15308 // induction_dictionaries_cnt = 0; // implied
15309
15310 if (attack_mode != ATTACK_MODE_BF)
15311 {
15312 if (keyspace == 0)
15313 {
15314 induction_dictionaries = scan_directory (induction_directory);
15315
15316 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15317 }
15318 }
15319
15320 if (induction_dictionaries_cnt)
15321 {
15322 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15323 }
15324
15325 /**
15326 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15327 */
15328 if (keyspace == 1)
15329 {
15330 if ((maskcnt > 1) || (dictcnt > 1))
15331 {
15332 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15333
15334 return (-1);
15335 }
15336 }
15337
15338 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15339 {
15340 char *subid = logfile_generate_subid ();
15341
15342 data.subid = subid;
15343
15344 logfile_sub_msg ("START");
15345
15346 data.devices_status = STATUS_INIT;
15347
15348 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15349 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15350 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15351
15352 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15353
15354 data.cpt_pos = 0;
15355
15356 data.cpt_start = time (NULL);
15357
15358 data.cpt_total = 0;
15359
15360 if (data.restore == 0)
15361 {
15362 rd->words_cur = skip;
15363
15364 skip = 0;
15365
15366 data.skip = 0;
15367 }
15368
15369 data.ms_paused = 0;
15370
15371 data.words_cur = rd->words_cur;
15372
15373 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15374 {
15375 hc_device_param_t *device_param = &data.devices_param[device_id];
15376
15377 device_param->speed_pos = 0;
15378
15379 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15380 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15381 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15382
15383 device_param->kernel_power = device_param->kernel_power_user;
15384 device_param->kernel_blocks = device_param->kernel_blocks_user;
15385
15386 device_param->outerloop_pos = 0;
15387 device_param->outerloop_left = 0;
15388 device_param->innerloop_pos = 0;
15389 device_param->innerloop_left = 0;
15390
15391 // some more resets:
15392
15393 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15394
15395 memset (device_param->pws_buf, 0, device_param->size_pws);
15396
15397 device_param->pw_cnt = 0;
15398 device_param->pws_cnt = 0;
15399
15400 device_param->words_off = 0;
15401 device_param->words_done = 0;
15402 }
15403
15404 data.kernel_blocks_div = 0;
15405
15406 // figure out some workload
15407
15408 if (attack_mode == ATTACK_MODE_STRAIGHT)
15409 {
15410 if (data.wordlist_mode == WL_MODE_FILE)
15411 {
15412 char *dictfile = NULL;
15413
15414 if (induction_dictionaries_cnt)
15415 {
15416 dictfile = induction_dictionaries[0];
15417 }
15418 else
15419 {
15420 dictfile = dictfiles[dictpos];
15421 }
15422
15423 data.dictfile = dictfile;
15424
15425 logfile_sub_string (dictfile);
15426
15427 for (uint i = 0; i < rp_files_cnt; i++)
15428 {
15429 logfile_sub_var_string ("rulefile", rp_files[i]);
15430 }
15431
15432 FILE *fd2 = fopen (dictfile, "rb");
15433
15434 if (fd2 == NULL)
15435 {
15436 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15437
15438 return (-1);
15439 }
15440
15441 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15442
15443 fclose (fd2);
15444
15445 if (data.words_cnt == 0)
15446 {
15447 if (data.devices_status == STATUS_CRACKED) break;
15448 if (data.devices_status == STATUS_ABORTED) break;
15449
15450 dictpos++;
15451
15452 continue;
15453 }
15454 }
15455 }
15456 else if (attack_mode == ATTACK_MODE_COMBI)
15457 {
15458 char *dictfile = data.dictfile;
15459 char *dictfile2 = data.dictfile2;
15460
15461 logfile_sub_string (dictfile);
15462 logfile_sub_string (dictfile2);
15463
15464 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15465 {
15466 FILE *fd2 = fopen (dictfile, "rb");
15467
15468 if (fd2 == NULL)
15469 {
15470 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15471
15472 return (-1);
15473 }
15474
15475 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15476
15477 fclose (fd2);
15478 }
15479 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15480 {
15481 FILE *fd2 = fopen (dictfile2, "rb");
15482
15483 if (fd2 == NULL)
15484 {
15485 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15486
15487 return (-1);
15488 }
15489
15490 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15491
15492 fclose (fd2);
15493 }
15494
15495 if (data.words_cnt == 0)
15496 {
15497 if (data.devices_status == STATUS_CRACKED) break;
15498 if (data.devices_status == STATUS_ABORTED) break;
15499
15500 dictpos++;
15501
15502 continue;
15503 }
15504 }
15505 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15506 {
15507 char *dictfile = NULL;
15508
15509 if (induction_dictionaries_cnt)
15510 {
15511 dictfile = induction_dictionaries[0];
15512 }
15513 else
15514 {
15515 dictfile = dictfiles[dictpos];
15516 }
15517
15518 data.dictfile = dictfile;
15519
15520 char *mask = data.mask;
15521
15522 logfile_sub_string (dictfile);
15523 logfile_sub_string (mask);
15524
15525 FILE *fd2 = fopen (dictfile, "rb");
15526
15527 if (fd2 == NULL)
15528 {
15529 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15530
15531 return (-1);
15532 }
15533
15534 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15535
15536 fclose (fd2);
15537
15538 if (data.words_cnt == 0)
15539 {
15540 if (data.devices_status == STATUS_CRACKED) break;
15541 if (data.devices_status == STATUS_ABORTED) break;
15542
15543 dictpos++;
15544
15545 continue;
15546 }
15547 }
15548 else if (attack_mode == ATTACK_MODE_BF)
15549 {
15550 local_free (css_buf);
15551 local_free (data.root_css_buf);
15552 local_free (data.markov_css_buf);
15553
15554 char *mask = dictfiles[dictpos];
15555
15556 logfile_sub_string (mask);
15557
15558 // base
15559
15560 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15561
15562 if (opts_type & OPTS_TYPE_PT_UNICODE)
15563 {
15564 uint css_cnt_unicode = css_cnt * 2;
15565
15566 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15567
15568 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15569 {
15570 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15571
15572 css_buf_unicode[j + 1].cs_buf[0] = 0;
15573 css_buf_unicode[j + 1].cs_len = 1;
15574 }
15575
15576 free (css_buf);
15577
15578 css_buf = css_buf_unicode;
15579 css_cnt = css_cnt_unicode;
15580 }
15581
15582 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15583
15584 uint mask_min = pw_min;
15585 uint mask_max = pw_max;
15586
15587 if (opts_type & OPTS_TYPE_PT_UNICODE)
15588 {
15589 mask_min *= 2;
15590 mask_max *= 2;
15591 }
15592
15593 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15594 {
15595 if (css_cnt < mask_min)
15596 {
15597 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15598 }
15599
15600 if (css_cnt > mask_max)
15601 {
15602 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15603 }
15604
15605 // skip to next mask
15606
15607 dictpos++;
15608
15609 rd->dictpos = dictpos;
15610
15611 logfile_sub_msg ("STOP");
15612
15613 continue;
15614 }
15615
15616 uint save_css_cnt = css_cnt;
15617
15618 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15619 {
15620 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15621 {
15622 uint salt_len = (uint) data.salts_buf[0].salt_len;
15623 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15624
15625 uint css_cnt_salt = css_cnt + salt_len;
15626
15627 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15628
15629 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15630
15631 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15632 {
15633 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15634 css_buf_salt[j].cs_len = 1;
15635 }
15636
15637 free (css_buf);
15638
15639 css_buf = css_buf_salt;
15640 css_cnt = css_cnt_salt;
15641 }
15642 }
15643
15644 data.mask = mask;
15645 data.css_cnt = css_cnt;
15646 data.css_buf = css_buf;
15647
15648 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15649
15650 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15651
15652 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15653
15654 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15655
15656 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15657 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15658
15659 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15660
15661 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15662
15663 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15664 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15665
15666 data.root_css_buf = root_css_buf;
15667 data.markov_css_buf = markov_css_buf;
15668
15669 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15670
15671 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15672
15673 local_free (root_table_buf);
15674 local_free (markov_table_buf);
15675
15676 // copy + args
15677
15678 uint css_cnt_l = css_cnt;
15679 uint css_cnt_r;
15680
15681 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15682 {
15683 if (save_css_cnt < 6)
15684 {
15685 css_cnt_r = 1;
15686 }
15687 else if (save_css_cnt == 6)
15688 {
15689 css_cnt_r = 2;
15690 }
15691 else
15692 {
15693 if (opts_type & OPTS_TYPE_PT_UNICODE)
15694 {
15695 if (save_css_cnt == 8 || save_css_cnt == 10)
15696 {
15697 css_cnt_r = 2;
15698 }
15699 else
15700 {
15701 css_cnt_r = 4;
15702 }
15703 }
15704 else
15705 {
15706 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15707 {
15708 css_cnt_r = 3;
15709 }
15710 else
15711 {
15712 css_cnt_r = 4;
15713 }
15714 }
15715 }
15716 }
15717 else
15718 {
15719 css_cnt_r = 1;
15720
15721 /* unfinished code?
15722 int sum = css_buf[css_cnt_r - 1].cs_len;
15723
15724 for (uint i = 1; i < 4 && i < css_cnt; i++)
15725 {
15726 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15727
15728 css_cnt_r++;
15729
15730 sum *= css_buf[css_cnt_r - 1].cs_len;
15731 }
15732 */
15733 }
15734
15735 css_cnt_l -= css_cnt_r;
15736
15737 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15738
15739 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15740 {
15741 hc_device_param_t *device_param = &data.devices_param[device_id];
15742
15743 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15744 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15745 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15746
15747 device_param->kernel_params_mp_l_buf64[3] = 0;
15748 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15749 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15750 device_param->kernel_params_mp_l_buf32[6] = 0;
15751 device_param->kernel_params_mp_l_buf32[7] = 0;
15752 device_param->kernel_params_mp_l_buf32[8] = 0;
15753
15754 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15755 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15756 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15757 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15758
15759 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15760 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15761 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15762
15763 device_param->kernel_params_mp_r_buf64[3] = 0;
15764 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15765 device_param->kernel_params_mp_r_buf32[5] = 0;
15766 device_param->kernel_params_mp_r_buf32[6] = 0;
15767 device_param->kernel_params_mp_r_buf32[7] = 0;
15768
15769 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]);
15770 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]);
15771 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]);
15772
15773 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]);
15774 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]);
15775 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]);
15776
15777 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);
15778 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);
15779 }
15780 }
15781
15782 uint64_t words_base = data.words_cnt;
15783
15784 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15785 {
15786 if (data.kernel_rules_cnt)
15787 {
15788 words_base /= data.kernel_rules_cnt;
15789 }
15790 }
15791 else if (data.attack_kern == ATTACK_KERN_COMBI)
15792 {
15793 if (data.combs_cnt)
15794 {
15795 words_base /= data.combs_cnt;
15796 }
15797 }
15798 else if (data.attack_kern == ATTACK_KERN_BF)
15799 {
15800 if (data.bfs_cnt)
15801 {
15802 words_base /= data.bfs_cnt;
15803 }
15804 }
15805
15806 data.words_base = words_base;
15807
15808 if (keyspace == 1)
15809 {
15810 log_info ("%llu", (unsigned long long int) words_base);
15811
15812 return (0);
15813 }
15814
15815 if (data.words_cur > data.words_base)
15816 {
15817 log_error ("ERROR: restore value greater keyspace");
15818
15819 return (-1);
15820 }
15821
15822 if (data.words_cur)
15823 {
15824 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15825 {
15826 for (uint i = 0; i < data.salts_cnt; i++)
15827 {
15828 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
15829 }
15830 }
15831 else if (data.attack_kern == ATTACK_KERN_COMBI)
15832 {
15833 for (uint i = 0; i < data.salts_cnt; i++)
15834 {
15835 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
15836 }
15837 }
15838 else if (data.attack_kern == ATTACK_KERN_BF)
15839 {
15840 for (uint i = 0; i < data.salts_cnt; i++)
15841 {
15842 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
15843 }
15844 }
15845 }
15846
15847 /*
15848 * Inform user about possible slow speeds
15849 */
15850
15851 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15852 {
15853 if (data.words_base < kernel_blocks_all)
15854 {
15855 if (quiet == 0)
15856 {
15857 log_info ("");
15858 log_info ("ATTENTION!");
15859 log_info (" The wordlist or mask you are using is too small.");
15860 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
15861 log_info (" The cracking speed will drop.");
15862 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
15863 log_info ("");
15864 }
15865 }
15866 }
15867
15868 /*
15869 * Update loopback file
15870 */
15871
15872 if (loopback == 1)
15873 {
15874 time_t now;
15875
15876 time (&now);
15877
15878 uint random_num = get_random_num (0, 9999);
15879
15880 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
15881
15882 data.loopback_file = loopback_file;
15883 }
15884
15885 /*
15886 * Update dictionary statistic
15887 */
15888
15889 if (keyspace == 0)
15890 {
15891 dictstat_fp = fopen (dictstat, "wb");
15892
15893 if (dictstat_fp)
15894 {
15895 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
15896
15897 fclose (dictstat_fp);
15898 }
15899 }
15900
15901 data.devices_status = STATUS_RUNNING;
15902
15903 if (initial_restore_done == 0)
15904 {
15905 if (data.restore_disable == 0) cycle_restore ();
15906
15907 initial_restore_done = 1;
15908 }
15909
15910 hc_timer_set (&data.timer_running);
15911
15912 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15913 {
15914 if ((quiet == 0) && (status == 0) && (benchmark == 0))
15915 {
15916 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
15917 if (quiet == 0) fflush (stdout);
15918 }
15919 }
15920 else if (wordlist_mode == WL_MODE_STDIN)
15921 {
15922 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
15923 if (data.quiet == 0) log_info ("");
15924 }
15925
15926 time_t runtime_start;
15927
15928 time (&runtime_start);
15929
15930 data.runtime_start = runtime_start;
15931
15932 /**
15933 * create cracker threads
15934 */
15935
15936 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
15937
15938 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15939 {
15940 hc_device_param_t *device_param = &devices_param[device_id];
15941
15942 device_param->device_id = device_id;
15943
15944 if (wordlist_mode == WL_MODE_STDIN)
15945 {
15946 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
15947 }
15948 else
15949 {
15950 hc_thread_create (c_threads[device_id], thread_calc, device_param);
15951 }
15952 }
15953
15954 // wait for crack threads to exit
15955
15956 hc_thread_wait (devices_cnt, c_threads);
15957
15958 local_free (c_threads);
15959
15960 data.restore = 0;
15961
15962 // finalize task
15963
15964 logfile_sub_var_uint ("status-after-work", data.devices_status);
15965
15966 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
15967
15968 if (data.devices_status == STATUS_CRACKED) break;
15969 if (data.devices_status == STATUS_ABORTED) break;
15970
15971 if (data.devices_status == STATUS_BYPASS)
15972 {
15973 data.devices_status = STATUS_RUNNING;
15974 }
15975
15976 if (induction_dictionaries_cnt)
15977 {
15978 unlink (induction_dictionaries[0]);
15979 }
15980
15981 free (induction_dictionaries);
15982
15983 if (attack_mode != ATTACK_MODE_BF)
15984 {
15985 induction_dictionaries = scan_directory (induction_directory);
15986
15987 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15988 }
15989
15990 if (benchmark == 0)
15991 {
15992 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
15993 {
15994 if (quiet == 0) clear_prompt ();
15995
15996 if (quiet == 0) log_info ("");
15997
15998 if (status == 1)
15999 {
16000 status_display ();
16001 }
16002 else
16003 {
16004 if (quiet == 0) status_display ();
16005 }
16006
16007 if (quiet == 0) log_info ("");
16008 }
16009 }
16010
16011 if (attack_mode == ATTACK_MODE_BF)
16012 {
16013 dictpos++;
16014
16015 rd->dictpos = dictpos;
16016 }
16017 else
16018 {
16019 if (induction_dictionaries_cnt)
16020 {
16021 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16022 }
16023 else
16024 {
16025 dictpos++;
16026
16027 rd->dictpos = dictpos;
16028 }
16029 }
16030
16031 time_t runtime_stop;
16032
16033 time (&runtime_stop);
16034
16035 data.runtime_stop = runtime_stop;
16036
16037 logfile_sub_uint (runtime_start);
16038 logfile_sub_uint (runtime_stop);
16039
16040 logfile_sub_msg ("STOP");
16041
16042 global_free (subid);
16043 }
16044
16045 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16046
16047 if (data.devices_status == STATUS_CRACKED) break;
16048 if (data.devices_status == STATUS_ABORTED) break;
16049 if (data.devices_status == STATUS_QUIT) break;
16050
16051 if (data.devices_status == STATUS_BYPASS)
16052 {
16053 data.devices_status = STATUS_RUNNING;
16054 }
16055 }
16056
16057 // 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
16058
16059 if (attack_mode == ATTACK_MODE_STRAIGHT)
16060 {
16061 if (data.wordlist_mode == WL_MODE_FILE)
16062 {
16063 if (data.dictfile == NULL)
16064 {
16065 if (dictfiles != NULL)
16066 {
16067 data.dictfile = dictfiles[0];
16068
16069 hc_timer_set (&data.timer_running);
16070 }
16071 }
16072 }
16073 }
16074 // NOTE: combi is okay because it is already set beforehand
16075 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16076 {
16077 if (data.dictfile == NULL)
16078 {
16079 if (dictfiles != NULL)
16080 {
16081 hc_timer_set (&data.timer_running);
16082
16083 data.dictfile = dictfiles[0];
16084 }
16085 }
16086 }
16087 else if (attack_mode == ATTACK_MODE_BF)
16088 {
16089 if (data.mask == NULL)
16090 {
16091 hc_timer_set (&data.timer_running);
16092
16093 data.mask = masks[0];
16094 }
16095 }
16096
16097 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16098 {
16099 data.devices_status = STATUS_EXHAUSTED;
16100 }
16101
16102 // if cracked / aborted remove last induction dictionary
16103
16104 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16105 {
16106 struct stat induct_stat;
16107
16108 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16109 {
16110 unlink (induction_dictionaries[file_pos]);
16111 }
16112 }
16113
16114 // wait for non-interactive threads
16115
16116 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16117 {
16118 hc_thread_wait (1, &ni_threads[thread_idx]);
16119 }
16120
16121 local_free (ni_threads);
16122
16123 // wait for interactive threads
16124
16125 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16126 {
16127 hc_thread_wait (1, &i_thread);
16128 }
16129
16130 // we dont need restore file anymore
16131 if (data.restore_disable == 0)
16132 {
16133 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16134 {
16135 unlink (eff_restore_file);
16136 unlink (new_restore_file);
16137 }
16138 else
16139 {
16140 cycle_restore ();
16141 }
16142 }
16143
16144 // finally save left hashes
16145
16146 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16147 {
16148 save_hash ();
16149 }
16150
16151 /**
16152 * Clean up
16153 */
16154
16155 if (benchmark == 1)
16156 {
16157 status_benchmark ();
16158
16159 log_info ("");
16160 }
16161 else
16162 {
16163 if (quiet == 0) clear_prompt ();
16164
16165 if (quiet == 0) log_info ("");
16166
16167 if (status == 1)
16168 {
16169 status_display ();
16170 }
16171 else
16172 {
16173 if (quiet == 0) status_display ();
16174 }
16175
16176 if (quiet == 0) log_info ("");
16177 }
16178
16179 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16180 {
16181 hc_device_param_t *device_param = &data.devices_param[device_id];
16182
16183 local_free (device_param->result);
16184
16185 local_free (device_param->pw_caches);
16186
16187 local_free (device_param->combs_buf);
16188
16189 local_free (device_param->hooks_buf);
16190
16191 local_free (device_param->device_name);
16192
16193 local_free (device_param->device_name_chksum);
16194
16195 local_free (device_param->device_version);
16196
16197 local_free (device_param->driver_version);
16198
16199 if (device_param->pws_buf) myfree (device_param->pws_buf);
16200 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16201 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16202 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16203 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16204 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16205 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16206 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16207 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16208 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16209 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16210 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16211 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16212 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16213 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16214 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16215 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16216 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16217 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16218 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16219 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16220 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16221 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16222 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16223 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16224 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16225 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16226 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16227 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16228
16229 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16230 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16231 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16232 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16233 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16234 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16235 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16236 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16237 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16238 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16239 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16240
16241 if (device_param->program) hc_clReleaseProgram (device_param->program);
16242 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16243 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16244 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16245 if (device_param->context) hc_clReleaseContext (device_param->context);
16246 }
16247
16248 // reset default fan speed
16249
16250 if (gpu_temp_disable == 0)
16251 {
16252 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16253 {
16254 hc_thread_mutex_lock (mux_adl);
16255
16256 for (uint i = 0; i < data.devices_cnt; i++)
16257 {
16258 if (data.hm_device[i].fan_supported == 1)
16259 {
16260 int fanspeed = temp_retain_fanspeed_value[i];
16261
16262 if (fanspeed == -1) continue;
16263
16264 int rc = hm_set_fanspeed_with_device_id_amd (i, fanspeed);
16265
16266 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
16267 }
16268 }
16269
16270 hc_thread_mutex_unlock (mux_adl);
16271 }
16272 }
16273
16274 // reset power tuning
16275
16276 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16277 {
16278 hc_thread_mutex_lock (mux_adl);
16279
16280 for (uint i = 0; i < data.devices_cnt; i++)
16281 {
16282 if (data.hm_device[i].od_version == 6)
16283 {
16284 // check powertune capabilities first, if not available then skip device
16285
16286 int powertune_supported = 0;
16287
16288 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
16289 {
16290 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16291
16292 return (-1);
16293 }
16294
16295 if (powertune_supported != 0)
16296 {
16297 // powercontrol settings
16298
16299 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, od_power_control_status[i])) != ADL_OK)
16300 {
16301 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16302
16303 return (-1);
16304 }
16305
16306 // clocks
16307
16308 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16309
16310 performance_state->iNumberOfPerformanceLevels = 2;
16311
16312 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
16313 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
16314 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
16315 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
16316
16317 if ((hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16318 {
16319 log_info ("ERROR: Failed to restore ADL performance state");
16320
16321 return (-1);
16322 }
16323
16324 local_free (performance_state);
16325 }
16326 }
16327 }
16328
16329 hc_thread_mutex_unlock (mux_adl);
16330 }
16331
16332 if (gpu_temp_disable == 0)
16333 {
16334 if (vendor_id == VENDOR_ID_NV)
16335 {
16336 #ifdef LINUX
16337 hc_NVML_nvmlShutdown (data.hm_dll);
16338 #endif
16339
16340 #ifdef WIN
16341 NvAPI_Unload ();
16342 #endif
16343 }
16344
16345 if (vendor_id == VENDOR_ID_AMD)
16346 {
16347 hc_ADL_Main_Control_Destroy (data.hm_dll);
16348
16349 hm_close (data.hm_dll);
16350 }
16351
16352 #ifdef LINUX
16353 if (vendor_id == VENDOR_ID_NV)
16354 {
16355 hm_close (data.hm_dll);
16356 }
16357 #endif
16358 }
16359
16360 // free memory
16361
16362 local_free (masks);
16363
16364 local_free (dictstat_base);
16365
16366 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16367 {
16368 pot_t *pot_ptr = &pot[pot_pos];
16369
16370 hash_t *hash = &pot_ptr->hash;
16371
16372 local_free (hash->digest);
16373
16374 if (isSalted)
16375 {
16376 local_free (hash->salt);
16377 }
16378 }
16379
16380 local_free (pot);
16381
16382 local_free (all_kernel_rules_cnt);
16383 local_free (all_kernel_rules_buf);
16384
16385 local_free (wl_data->buf);
16386 local_free (wl_data);
16387
16388 local_free (bitmap_s1_a);
16389 local_free (bitmap_s1_b);
16390 local_free (bitmap_s1_c);
16391 local_free (bitmap_s1_d);
16392 local_free (bitmap_s2_a);
16393 local_free (bitmap_s2_b);
16394 local_free (bitmap_s2_c);
16395 local_free (bitmap_s2_d);
16396
16397 local_free (temp_retain_fanspeed_value);
16398 local_free (od_clock_mem_status);
16399 local_free (od_power_control_status);
16400
16401 global_free (devices_param);
16402
16403 global_free (kernel_rules_buf);
16404
16405 global_free (root_css_buf);
16406 global_free (markov_css_buf);
16407
16408 global_free (digests_buf);
16409 global_free (digests_shown);
16410 global_free (digests_shown_tmp);
16411
16412 global_free (salts_buf);
16413 global_free (salts_shown);
16414
16415 global_free (esalts_buf);
16416
16417 global_free (words_progress_done);
16418 global_free (words_progress_rejected);
16419 global_free (words_progress_restored);
16420
16421 if (pot_fp) fclose (pot_fp);
16422
16423 if (data.devices_status == STATUS_QUIT) break;
16424 }
16425
16426 // destroy others mutex
16427
16428 hc_thread_mutex_delete (mux_dispatcher);
16429 hc_thread_mutex_delete (mux_counter);
16430 hc_thread_mutex_delete (mux_display);
16431 hc_thread_mutex_delete (mux_adl);
16432
16433 // free memory
16434
16435 local_free (eff_restore_file);
16436 local_free (new_restore_file);
16437
16438 local_free (rd);
16439
16440 // loopback
16441
16442 local_free (loopback_file);
16443
16444 if (loopback == 1) unlink (loopback_file);
16445
16446 // induction directory
16447
16448 if (induction_dir == NULL)
16449 {
16450 if (attack_mode != ATTACK_MODE_BF)
16451 {
16452 if (rmdir (induction_directory) == -1)
16453 {
16454 if (errno == ENOENT)
16455 {
16456 // good, we can ignore
16457 }
16458 else if (errno == ENOTEMPTY)
16459 {
16460 // good, we can ignore
16461 }
16462 else
16463 {
16464 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16465
16466 return (-1);
16467 }
16468 }
16469
16470 local_free (induction_directory);
16471 }
16472 }
16473
16474 // outfile-check directory
16475
16476 if (outfile_check_dir == NULL)
16477 {
16478 if (rmdir (outfile_check_directory) == -1)
16479 {
16480 if (errno == ENOENT)
16481 {
16482 // good, we can ignore
16483 }
16484 else if (errno == ENOTEMPTY)
16485 {
16486 // good, we can ignore
16487 }
16488 else
16489 {
16490 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16491
16492 return (-1);
16493 }
16494 }
16495
16496 local_free (outfile_check_directory);
16497 }
16498
16499 time_t proc_stop;
16500
16501 time (&proc_stop);
16502
16503 logfile_top_uint (proc_start);
16504 logfile_top_uint (proc_stop);
16505
16506 logfile_top_msg ("STOP");
16507
16508 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16509 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16510
16511 if (data.devices_status == STATUS_ABORTED) return 2;
16512 if (data.devices_status == STATUS_QUIT) return 2;
16513 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16514 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16515 if (data.devices_status == STATUS_CRACKED) return 0;
16516
16517 return -1;
16518 }
Hashcat additions to support pwdhash