projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Added option --opencl-device-types to filter for specific OpenCL device types
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Author......: Jens Steube <jens.steube@gmail.com>
3 * License.....: MIT
4 */
5
6 #include <common.h>
7 #include <shared.h>
8 #include <rp_kernel_on_cpu.h>
9 #include <getopt.h>
10
11 const char *PROGNAME = "oclHashcat";
12 const char *VERSION_TXT = "2.10";
13 const uint VERSION_BIN = 210;
14 const uint RESTORE_MIN = 210;
15
16 #define INCR_RULES 10000
17 #define INCR_SALTS 100000
18 #define INCR_MASKS 1000
19 #define INCR_POT 1000
20
21 #define USAGE 0
22 #define VERSION 0
23 #define QUIET 0
24 #define MARKOV_THRESHOLD 0
25 #define MARKOV_DISABLE 0
26 #define MARKOV_CLASSIC 0
27 #define BENCHMARK 0
28 #define BENCHMARK_MODE 1
29 #define RESTORE 0
30 #define RESTORE_TIMER 60
31 #define RESTORE_DISABLE 0
32 #define STATUS 0
33 #define STATUS_TIMER 10
34 #define STATUS_AUTOMAT 0
35 #define LOOPBACK 0
36 #define WEAK_HASH_THRESHOLD 100
37 #define SHOW 0
38 #define LEFT 0
39 #define USERNAME 0
40 #define REMOVE 0
41 #define REMOVE_TIMER 60
42 #define SKIP 0
43 #define LIMIT 0
44 #define KEYSPACE 0
45 #define POTFILE_DISABLE 0
46 #define DEBUG_MODE 0
47 #define RP_GEN 0
48 #define RP_GEN_FUNC_MIN 1
49 #define RP_GEN_FUNC_MAX 4
50 #define RP_GEN_SEED 0
51 #define RULE_BUF_L ":"
52 #define RULE_BUF_R ":"
53 #define FORCE 0
54 #define RUNTIME 0
55 #define HEX_CHARSET 0
56 #define HEX_SALT 0
57 #define HEX_WORDLIST 0
58 #define OUTFILE_FORMAT 3
59 #define OUTFILE_AUTOHEX 1
60 #define OUTFILE_CHECK_TIMER 5
61 #define ATTACK_MODE 0
62 #define HASH_MODE 0
63 #define SEGMENT_SIZE 32
64 #define INCREMENT 0
65 #define INCREMENT_MIN 1
66 #define INCREMENT_MAX PW_MAX
67 #define SEPARATOR ':'
68 #define BITMAP_MIN 16
69 #define BITMAP_MAX 24
70 #define GPU_TEMP_DISABLE 0
71 #define GPU_TEMP_ABORT 90
72 #define GPU_TEMP_RETAIN 80
73 #define WORKLOAD_PROFILE 2
74 #define KERNEL_ACCEL 0
75 #define KERNEL_LOOPS 0
76 #define KERNEL_RULES 1024
77 #define KERNEL_COMBS 1024
78 #define KERNEL_BFS 1024
79 #define KERNEL_THREADS 64
80 #define POWERTUNE_ENABLE 0
81 #define LOGFILE_DISABLE 0
82 #define SCRYPT_TMTO 0
83
84 #define WL_MODE_STDIN 1
85 #define WL_MODE_FILE 2
86 #define WL_MODE_MASK 3
87
88 #define HL_MODE_FILE 4
89 #define HL_MODE_ARG 5
90
91 #define HLFMT_HASHCAT 0
92 #define HLFMT_PWDUMP 1
93 #define HLFMT_PASSWD 2
94 #define HLFMT_SHADOW 3
95 #define HLFMT_DCC 4
96 #define HLFMT_DCC2 5
97 #define HLFMT_NETNTLM1 7
98 #define HLFMT_NETNTLM2 8
99 #define HLFMT_NSLDAP 9
100 #define HLFMT_NSLDAPS 10
101 #define HLFMTS_CNT 11
102
103 #define ATTACK_MODE_STRAIGHT 0
104 #define ATTACK_MODE_COMBI 1
105 #define ATTACK_MODE_TOGGLE 2
106 #define ATTACK_MODE_BF 3
107 #define ATTACK_MODE_PERM 4
108 #define ATTACK_MODE_TABLE 5
109 #define ATTACK_MODE_HYBRID1 6
110 #define ATTACK_MODE_HYBRID2 7
111 #define ATTACK_MODE_NONE 100
112
113 #define ATTACK_KERN_STRAIGHT 0
114 #define ATTACK_KERN_COMBI 1
115 #define ATTACK_KERN_BF 3
116 #define ATTACK_KERN_NONE 100
117
118 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
119 #define ATTACK_EXEC_INSIDE_KERNEL 11
120
121 #define COMBINATOR_MODE_BASE_LEFT 10001
122 #define COMBINATOR_MODE_BASE_RIGHT 10002
123
124 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
125 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
126
127 #define MAX_CUT_TRIES 4
128
129 #define MAX_DICTSTAT 10000
130
131 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
132
133 #define global_free(attr) \
134 { \
135 myfree ((void *) data.attr); \
136 \
137 data.attr = NULL; \
138 }
139
140 #define local_free(attr) \
141 { \
142 myfree ((void *) attr); \
143 \
144 attr = NULL; \
145 }
146
147 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
148 {
149 900,
150 0,
151 5100,
152 100,
153 1400,
154 10800,
155 1700,
156 5000,
157 10100,
158 6000,
159 6100,
160 6900,
161 11700,
162 11800,
163 400,
164 8900,
165 11900,
166 12000,
167 10900,
168 12100,
169 23,
170 2500,
171 5300,
172 5400,
173 5500,
174 5600,
175 7300,
176 7500,
177 8300,
178 11100,
179 11200,
180 11400,
181 121,
182 2611,
183 2711,
184 2811,
185 8400,
186 11,
187 2612,
188 7900,
189 21,
190 11000,
191 124,
192 10000,
193 3711,
194 7600,
195 12,
196 131,
197 132,
198 1731,
199 200,
200 300,
201 3100,
202 112,
203 12300,
204 8000,
205 141,
206 1441,
207 1600,
208 12600,
209 1421,
210 101,
211 111,
212 1711,
213 3000,
214 1000,
215 1100,
216 2100,
217 12800,
218 1500,
219 12400,
220 500,
221 3200,
222 7400,
223 1800,
224 122,
225 1722,
226 7100,
227 6300,
228 6700,
229 6400,
230 6500,
231 2400,
232 2410,
233 5700,
234 9200,
235 9300,
236 22,
237 501,
238 5800,
239 8100,
240 8500,
241 7200,
242 9900,
243 7700,
244 7800,
245 10300,
246 8600,
247 8700,
248 9100,
249 133,
250 11600,
251 12500,
252 13000,
253 6211,
254 6221,
255 6231,
256 6241,
257 8800,
258 12900,
259 12200,
260 9700,
261 9710,
262 9800,
263 9810,
264 9400,
265 9500,
266 9600,
267 10400,
268 10410,
269 10500,
270 10600,
271 10700,
272 9000,
273 5200,
274 6800,
275 6600,
276 8200,
277 11300,
278 12700
279 };
280
281 /**
282 * types
283 */
284
285 static void (*get_next_word_func) (char *, uint32_t, uint32_t *, uint32_t *);
286
287 /**
288 * globals
289 */
290
291 static unsigned int full01 = 0x01010101;
292 static unsigned int full80 = 0x80808080;
293
294 int SUPPRESS_OUTPUT = 0;
295
296 hc_thread_mutex_t mux_adl;
297 hc_thread_mutex_t mux_counter;
298 hc_thread_mutex_t mux_dispatcher;
299 hc_thread_mutex_t mux_display;
300
301 hc_global_data_t data;
302
303 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
304
305 const char *USAGE_MINI[] =
306 {
307 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
308 "",
309 "Try --help for more help.",
310 NULL
311 };
312
313 const char *USAGE_BIG[] =
314 {
315 "%s, advanced password recovery",
316 "",
317 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
318 "",
319 "=======",
320 "Options",
321 "=======",
322 "",
323 "* General:",
324 "",
325 " -m, --hash-type=NUM Hash-type, see references below",
326 " -a, --attack-mode=NUM Attack-mode, see references below",
327 " -V, --version Print version",
328 " -h, --help Print help",
329 " --quiet Suppress output",
330 "",
331 "* Benchmark:",
332 "",
333 " -b, --benchmark Run benchmark",
334 " --benchmark-mode=NUM Benchmark-mode, see references below",
335 "",
336 "* Misc:",
337 "",
338 " --hex-charset Assume charset is given in hex",
339 " --hex-salt Assume salt is given in hex",
340 " --hex-wordlist Assume words in wordlist is given in hex",
341 " --force Ignore warnings",
342 " --status Enable automatic update of the status-screen",
343 " --status-timer=NUM Seconds between status-screen update",
344 " --status-automat Display the status view in a machine readable format",
345 " --loopback Add new plains to induct directory",
346 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
347 "",
348 "* Markov:",
349 "",
350 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
351 " --markov-disable Disables markov-chains, emulates classic brute-force",
352 " --markov-classic Enables classic markov-chains, no per-position enhancement",
353 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
354 "",
355 "* Session:",
356 "",
357 " --runtime=NUM Abort session after NUM seconds of runtime",
358 " --session=STR Define specific session name",
359 " --restore Restore session from --session",
360 " --restore-disable Do not write restore file",
361 "",
362 "* Files:",
363 "",
364 " -o, --outfile=FILE Define outfile for recovered hash",
365 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
366 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
367 " --outfile-check-timer=NUM Seconds between outfile checks",
368 " -p, --separator=CHAR Separator char for hashlists and outfile",
369 " --show Show cracked passwords only",
370 " --left Show un-cracked passwords only",
371 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
372 " --remove Enable remove of hash once it is cracked",
373 " --remove-timer=NUM Update input hash file each NUM seconds",
374 " --potfile-disable Do not write potfile",
375 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
376 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
377 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
378 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
379 " --logfile-disable Disable the logfile",
380 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
381 "",
382 "* Resources:",
383 "",
384 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
385 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
386 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
387 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
388 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
389 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
390 " --opencl-platform=NUM OpenCL platform to use, in case multiple platforms are present",
391 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
392 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
393 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
394 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
395 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
396 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
397 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
398 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
399 "",
400 "* Distributed:",
401 "",
402 " -s, --skip=NUM Skip number of words",
403 " -l, --limit=NUM Limit number of words",
404 " --keyspace Show keyspace base:mod values and quit",
405 "",
406 "* Rules:",
407 "",
408 " -j, --rule-left=RULE Single rule applied to each word from left dict",
409 " -k, --rule-right=RULE Single rule applied to each word from right dict",
410 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
411 " -g, --generate-rules=NUM Generate NUM random rules",
412 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
413 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
414 " --generate-rules-seed=NUM Force RNG seed to NUM",
415 "",
416 "* Custom charsets:",
417 "",
418 " -1, --custom-charset1=CS User-defined charsets",
419 " -2, --custom-charset2=CS Example:",
420 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
421 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
422 "",
423 "* Increment:",
424 "",
425 " -i, --increment Enable increment mode",
426 " --increment-min=NUM Start incrementing at NUM",
427 " --increment-max=NUM Stop incrementing at NUM",
428 "",
429 "==========",
430 "References",
431 "==========",
432 "",
433 "* Workload Profile:",
434 "",
435 " 1 = Reduced performance profile (low latency desktop)",
436 " 2 = Default performance profile",
437 " 3 = Tuned performance profile (high latency desktop)",
438 "",
439 "* Benchmark Settings:",
440 "",
441 " 0 = Manual Tuning",
442 " 1 = Performance Tuning, default",
443 "",
444 "* OpenCL device-types:",
445 "",
446 " 1 = CPU devices",
447 " 2 = GPU devices",
448 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
449 "",
450 "* Outfile Formats:",
451 "",
452 " 1 = hash[:salt]",
453 " 2 = plain",
454 " 3 = hash[:salt]:plain",
455 " 4 = hex_plain",
456 " 5 = hash[:salt]:hex_plain",
457 " 6 = plain:hex_plain",
458 " 7 = hash[:salt]:plain:hex_plain",
459 " 8 = crackpos",
460 " 9 = hash[:salt]:crackpos",
461 " 10 = plain:crackpos",
462 " 11 = hash[:salt]:plain:crackpos",
463 " 12 = hex_plain:crackpos",
464 " 13 = hash[:salt]:hex_plain:crackpos",
465 " 14 = plain:hex_plain:crackpos",
466 " 15 = hash[:salt]:plain:hex_plain:crackpos",
467 "",
468 "* Debug mode output formats (for hybrid mode only, by using rules):",
469 "",
470 " 1 = save finding rule",
471 " 2 = save original word",
472 " 3 = save original word and finding rule",
473 " 4 = save original word, finding rule and modified plain",
474 "",
475 "* Built-in charsets:",
476 "",
477 " ?l = abcdefghijklmnopqrstuvwxyz",
478 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
479 " ?d = 0123456789",
480 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
481 " ?a = ?l?u?d?s",
482 " ?b = 0x00 - 0xff",
483 "",
484 "* Attack modes:",
485 "",
486 " 0 = Straight",
487 " 1 = Combination",
488 " 3 = Brute-force",
489 " 6 = Hybrid dict + mask",
490 " 7 = Hybrid mask + dict",
491 "",
492 "* Hash types:",
493 "",
494 "[[ Roll-your-own: Raw Hashes ]]",
495 "",
496 " 900 = MD4",
497 " 0 = MD5",
498 " 5100 = Half MD5",
499 " 100 = SHA1",
500 " 10800 = SHA-384",
501 " 1400 = SHA-256",
502 " 1700 = SHA-512",
503 " 5000 = SHA-3(Keccak)",
504 " 10100 = SipHash",
505 " 6000 = RipeMD160",
506 " 6100 = Whirlpool",
507 " 6900 = GOST R 34.11-94",
508 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
509 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
510 "",
511 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
512 "",
513 " 10 = md5($pass.$salt)",
514 " 20 = md5($salt.$pass)",
515 " 30 = md5(unicode($pass).$salt)",
516 " 40 = md5($salt.unicode($pass))",
517 " 3800 = md5($salt.$pass.$salt)",
518 " 3710 = md5($salt.md5($pass))",
519 " 2600 = md5(md5($pass)",
520 " 4300 = md5(strtoupper(md5($pass)))",
521 " 4400 = md5(sha1($pass))",
522 " 110 = sha1($pass.$salt)",
523 " 120 = sha1($salt.$pass)",
524 " 130 = sha1(unicode($pass).$salt)",
525 " 140 = sha1($salt.unicode($pass))",
526 " 4500 = sha1(sha1($pass)",
527 " 4700 = sha1(md5($pass))",
528 " 4900 = sha1($salt.$pass.$salt)",
529 " 1410 = sha256($pass.$salt)",
530 " 1420 = sha256($salt.$pass)",
531 " 1430 = sha256(unicode($pass).$salt)",
532 " 1440 = sha256($salt.unicode($pass))",
533 " 1710 = sha512($pass.$salt)",
534 " 1720 = sha512($salt.$pass)",
535 " 1730 = sha512(unicode($pass).$salt)",
536 " 1740 = sha512($salt.unicode($pass))",
537 "",
538 "[[ Roll-your-own: Authenticated Hashes ]]",
539 "",
540 " 50 = HMAC-MD5 (key = $pass)",
541 " 60 = HMAC-MD5 (key = $salt)",
542 " 150 = HMAC-SHA1 (key = $pass)",
543 " 160 = HMAC-SHA1 (key = $salt)",
544 " 1450 = HMAC-SHA256 (key = $pass)",
545 " 1460 = HMAC-SHA256 (key = $salt)",
546 " 1750 = HMAC-SHA512 (key = $pass)",
547 " 1760 = HMAC-SHA512 (key = $salt)",
548 "",
549 "[[ Generic KDF ]]",
550 "",
551 " 400 = phpass",
552 " 8900 = scrypt",
553 " 11900 = PBKDF2-HMAC-MD5",
554 " 12000 = PBKDF2-HMAC-SHA1",
555 " 10900 = PBKDF2-HMAC-SHA256",
556 " 12100 = PBKDF2-HMAC-SHA512",
557 "",
558 "[[ Network protocols, Challenge-Response ]]",
559 "",
560 " 23 = Skype",
561 " 2500 = WPA/WPA2",
562 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
563 " 5300 = IKE-PSK MD5",
564 " 5400 = IKE-PSK SHA1",
565 " 5500 = NetNTLMv1",
566 " 5500 = NetNTLMv1 + ESS",
567 " 5600 = NetNTLMv2",
568 " 7300 = IPMI2 RAKP HMAC-SHA1",
569 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
570 " 8300 = DNSSEC (NSEC3)",
571 " 10200 = Cram MD5",
572 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
573 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
574 " 11400 = SIP digest authentication (MD5)",
575 "",
576 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
577 "",
578 " 121 = SMF (Simple Machines Forum)",
579 " 400 = phpBB3",
580 " 2611 = vBulletin < v3.8.5",
581 " 2711 = vBulletin > v3.8.5",
582 " 2811 = MyBB",
583 " 2811 = IPB (Invison Power Board)",
584 " 8400 = WBB3 (Woltlab Burning Board)",
585 " 11 = Joomla < 2.5.18",
586 " 400 = Joomla > 2.5.18",
587 " 400 = Wordpress",
588 " 2612 = PHPS",
589 " 7900 = Drupal7",
590 " 21 = osCommerce",
591 " 21 = xt:Commerce",
592 " 11000 = PrestaShop",
593 " 124 = Django (SHA-1)",
594 " 10000 = Django (PBKDF2-SHA256)",
595 " 3711 = Mediawiki B type",
596 " 7600 = Redmine",
597 "",
598 "[[ Database Server ]]",
599 "",
600 " 12 = PostgreSQL",
601 " 131 = MSSQL(2000)",
602 " 132 = MSSQL(2005)",
603 " 1731 = MSSQL(2012)",
604 " 1731 = MSSQL(2014)",
605 " 200 = MySQL323",
606 " 300 = MySQL4.1/MySQL5",
607 " 3100 = Oracle H: Type (Oracle 7+)",
608 " 112 = Oracle S: Type (Oracle 11+)",
609 " 12300 = Oracle T: Type (Oracle 12+)",
610 " 8000 = Sybase ASE",
611 "",
612 "[[ HTTP, SMTP, LDAP Server ]]",
613 "",
614 " 141 = EPiServer 6.x < v4",
615 " 1441 = EPiServer 6.x > v4",
616 " 1600 = Apache $apr1$",
617 " 12600 = ColdFusion 10+",
618 " 1421 = hMailServer",
619 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
620 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
621 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
622 "",
623 "[[ Checksums ]]",
624 "",
625 " 11500 = CRC32",
626 "",
627 "[[ Operating-Systems ]]",
628 "",
629 " 3000 = LM",
630 " 1000 = NTLM",
631 " 1100 = Domain Cached Credentials (DCC), MS Cache",
632 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
633 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
634 " 1500 = descrypt, DES(Unix), Traditional DES",
635 " 12400 = BSDiCrypt, Extended DES",
636 " 500 = md5crypt $1$, MD5(Unix)",
637 " 3200 = bcrypt $2*$, Blowfish(Unix)",
638 " 7400 = sha256crypt $5$, SHA256(Unix)",
639 " 1800 = sha512crypt $6$, SHA512(Unix)",
640 " 122 = OSX v10.4",
641 " 122 = OSX v10.5",
642 " 122 = OSX v10.6",
643 " 1722 = OSX v10.7",
644 " 7100 = OSX v10.8",
645 " 7100 = OSX v10.9",
646 " 7100 = OSX v10.10",
647 " 6300 = AIX {smd5}",
648 " 6700 = AIX {ssha1}",
649 " 6400 = AIX {ssha256}",
650 " 6500 = AIX {ssha512}",
651 " 2400 = Cisco-PIX",
652 " 2410 = Cisco-ASA",
653 " 500 = Cisco-IOS $1$",
654 " 5700 = Cisco-IOS $4$",
655 " 9200 = Cisco-IOS $8$",
656 " 9300 = Cisco-IOS $9$",
657 " 22 = Juniper Netscreen/SSG (ScreenOS)",
658 " 501 = Juniper IVE",
659 " 5800 = Android PIN",
660 " 8100 = Citrix Netscaler",
661 " 8500 = RACF",
662 " 7200 = GRUB 2",
663 " 9900 = Radmin2",
664 "",
665 "[[ Enterprise Application Software (EAS) ]]",
666 "",
667 " 7700 = SAP CODVN B (BCODE)",
668 " 7800 = SAP CODVN F/G (PASSCODE)",
669 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
670 " 8600 = Lotus Notes/Domino 5",
671 " 8700 = Lotus Notes/Domino 6",
672 " 9100 = Lotus Notes/Domino 8",
673 " 133 = PeopleSoft",
674 "",
675 "[[ Archives ]]",
676 "",
677 " 11600 = 7-Zip",
678 " 12500 = RAR3-hp",
679 " 13000 = RAR5",
680 "",
681 "[[ Full-Disk encryptions (FDE) ]]",
682 "",
683 " 62XY = TrueCrypt 5.0+",
684 " X = 1 = PBKDF2-HMAC-RipeMD160",
685 " X = 2 = PBKDF2-HMAC-SHA512",
686 " X = 3 = PBKDF2-HMAC-Whirlpool",
687 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
688 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
689 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
690 " Y = 3 = XTS 1536 bit (Ciphers: All)",
691 " 8800 = Android FDE < v4.3",
692 " 12900 = Android FDE (Samsung DEK)",
693 " 12200 = eCryptfs",
694 "",
695 "[[ Documents ]]",
696 "",
697 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
698 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
699 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
700 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
701 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
702 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
703 " 9400 = MS Office 2007",
704 " 9500 = MS Office 2010",
705 " 9600 = MS Office 2013",
706 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
707 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
708 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
709 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
710 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
711 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
712 "",
713 "[[ Password Managers ]]",
714 "",
715 " 9000 = Password Safe v2",
716 " 5200 = Password Safe v3",
717 " 6800 = Lastpass",
718 " 6600 = 1Password, agilekeychain",
719 " 8200 = 1Password, cloudkeychain",
720 " 11300 = Bitcoin/Litecoin wallet.dat",
721 " 12700 = Blockchain, My Wallet",
722 "",
723 NULL
724 };
725
726 /**
727 * oclHashcat specific functions
728 */
729
730 void status_display_automat ()
731 {
732 FILE *out = stdout;
733
734 fprintf (out, "STATUS\t%u\t", data.devices_status);
735
736 /**
737 * speed new
738 */
739
740 fprintf (out, "SPEED\t");
741
742 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
743 {
744 hc_device_param_t *device_param = &data.devices_param[device_id];
745
746 uint64_t speed_cnt = 0;
747 float speed_ms = 0;
748
749 for (int i = 0; i < SPEED_CACHE; i++)
750 {
751 float rec_ms;
752
753 hc_timer_get (device_param->speed_rec[i], rec_ms);
754
755 if (rec_ms > SPEED_MAXAGE) continue;
756
757 speed_cnt += device_param->speed_cnt[i];
758 speed_ms += device_param->speed_ms[i];
759 }
760
761 speed_cnt /= SPEED_CACHE;
762 speed_ms /= SPEED_CACHE;
763
764 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
765 }
766
767 /**
768 * words_cur
769 */
770
771 uint64_t words_cur = get_lowest_words_done ();
772
773 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
774
775 /**
776 * counter
777 */
778
779 uint salts_left = data.salts_cnt - data.salts_done;
780
781 if (salts_left == 0) salts_left = 1;
782
783 uint64_t progress_total = data.words_cnt * salts_left;
784
785 uint64_t all_done = 0;
786 uint64_t all_rejected = 0;
787 uint64_t all_restored = 0;
788
789 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
790 {
791 if (salts_left > 1)
792 {
793 // otherwise the final cracked status shows 0/XXX progress
794
795 if (data.salts_shown[salt_pos] == 1) continue;
796 }
797
798 all_done += data.words_progress_done[salt_pos];
799 all_rejected += data.words_progress_rejected[salt_pos];
800 all_restored += data.words_progress_restored[salt_pos];
801 }
802
803 uint64_t progress_cur = all_restored + all_done + all_rejected;
804 uint64_t progress_end = progress_total;
805
806 uint64_t progress_skip = 0;
807
808 if (data.skip)
809 {
810 progress_skip = MIN (data.skip, data.words_base) * salts_left;
811
812 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
813 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
814 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
815 }
816
817 if (data.limit)
818 {
819 progress_end = MIN (data.limit, data.words_base) * salts_left;
820
821 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
822 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
823 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
824 }
825
826 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
827 uint64_t progress_end_relative_skip = progress_end - progress_skip;
828
829 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
830
831 /**
832 * cracks
833 */
834
835 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
836 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
837
838 /**
839 * temperature
840 */
841
842 if (data.gpu_temp_disable == 0)
843 {
844 fprintf (out, "TEMP\t");
845
846 hc_thread_mutex_lock (mux_adl);
847
848 for (uint i = 0; i < data.devices_cnt; i++)
849 {
850 int temp = hm_get_temperature_with_device_id (i);
851
852 fprintf (out, "%d\t", temp);
853 }
854
855 hc_thread_mutex_unlock (mux_adl);
856 }
857
858 #ifdef _WIN
859 fputc ('\r', out);
860 fputc ('\n', out);
861 #endif
862
863 #ifdef _POSIX
864 fputc ('\n', out);
865 #endif
866
867 fflush (out);
868 }
869
870 void status_display ()
871 {
872 if (data.devices_status == STATUS_INIT) return;
873 if (data.devices_status == STATUS_STARTING) return;
874 if (data.devices_status == STATUS_BYPASS) return;
875
876 if (data.status_automat == 1)
877 {
878 status_display_automat ();
879
880 return;
881 }
882
883 char tmp_buf[1000];
884
885 uint tmp_len = 0;
886
887 log_info ("Session.Name...: %s", data.session);
888
889 char *status_type = strstatus (data.devices_status);
890
891 uint hash_mode = data.hash_mode;
892
893 char *hash_type = strhashtype (hash_mode); // not a bug
894
895 log_info ("Status.........: %s", status_type);
896
897 /**
898 * show rules
899 */
900
901 if (data.rp_files_cnt)
902 {
903 uint i;
904
905 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
906 {
907 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
908 }
909
910 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
911
912 log_info ("Rules.Type.....: %s", tmp_buf);
913
914 tmp_len = 0;
915 }
916
917 if (data.rp_gen)
918 {
919 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
920
921 if (data.rp_gen_seed)
922 {
923 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
924 }
925 }
926
927 /**
928 * show input
929 */
930
931 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
932 {
933 if (data.wordlist_mode == WL_MODE_FILE)
934 {
935 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
936 }
937 else if (data.wordlist_mode == WL_MODE_STDIN)
938 {
939 log_info ("Input.Mode.....: Pipe");
940 }
941 }
942 else if (data.attack_mode == ATTACK_MODE_COMBI)
943 {
944 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
945 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
946 }
947 else if (data.attack_mode == ATTACK_MODE_BF)
948 {
949 char *mask = data.mask;
950
951 if (mask != NULL)
952 {
953 uint mask_len = data.css_cnt;
954
955 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
956
957 if (mask_len > 0)
958 {
959 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
960 {
961 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
962 {
963 mask_len -= data.salts_buf[0].salt_len;
964 }
965 }
966
967 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
968
969 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
970 }
971
972 if (data.maskcnt > 1)
973 {
974 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
975
976 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
977 }
978
979 log_info ("Input.Mode.....: %s", tmp_buf);
980 }
981
982 tmp_len = 0;
983 }
984 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
985 {
986 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
987 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
988 }
989 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
990 {
991 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
992 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
993 }
994
995 if (data.digests_cnt == 1)
996 {
997 if (data.hash_mode == 2500)
998 {
999 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1000
1001 uint pke[25];
1002
1003 char *pke_ptr = (char *) pke;
1004
1005 for (uint i = 0; i < 25; i++)
1006 {
1007 pke[i] = byte_swap_32 (wpa->pke[i]);
1008 }
1009
1010 char mac1[6];
1011 char mac2[6];
1012
1013 memcpy (mac1, pke_ptr + 23, 6);
1014 memcpy (mac2, pke_ptr + 29, 6);
1015
1016 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1017 (char *) data.salts_buf[0].salt_buf,
1018 mac1[0] & 0xff,
1019 mac1[1] & 0xff,
1020 mac1[2] & 0xff,
1021 mac1[3] & 0xff,
1022 mac1[4] & 0xff,
1023 mac1[5] & 0xff,
1024 mac2[0] & 0xff,
1025 mac2[1] & 0xff,
1026 mac2[2] & 0xff,
1027 mac2[3] & 0xff,
1028 mac2[4] & 0xff,
1029 mac2[5] & 0xff);
1030 }
1031 else if (data.hash_mode == 5200)
1032 {
1033 log_info ("Hash.Target....: File (%s)", data.hashfile);
1034 }
1035 else if (data.hash_mode == 9000)
1036 {
1037 log_info ("Hash.Target....: File (%s)", data.hashfile);
1038 }
1039 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1040 {
1041 log_info ("Hash.Target....: File (%s)", data.hashfile);
1042 }
1043 else
1044 {
1045 char out_buf[4096];
1046
1047 ascii_digest (out_buf, 0, 0);
1048
1049 // limit length
1050 if (strlen (out_buf) > 40)
1051 {
1052 out_buf[41] = '.';
1053 out_buf[42] = '.';
1054 out_buf[43] = '.';
1055 out_buf[44] = 0;
1056 }
1057
1058 log_info ("Hash.Target....: %s", out_buf);
1059 }
1060 }
1061 else
1062 {
1063 if (data.hash_mode == 3000)
1064 {
1065 char out_buf1[4096];
1066 char out_buf2[4096];
1067
1068 ascii_digest (out_buf1, 0, 0);
1069 ascii_digest (out_buf2, 0, 1);
1070
1071 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1072 }
1073 else
1074 {
1075 log_info ("Hash.Target....: File (%s)", data.hashfile);
1076 }
1077 }
1078
1079 log_info ("Hash.Type......: %s", hash_type);
1080
1081 /**
1082 * speed new
1083 */
1084
1085 uint64_t speed_cnt[DEVICES_MAX];
1086 float speed_ms[DEVICES_MAX];
1087
1088 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1089 {
1090 hc_device_param_t *device_param = &data.devices_param[device_id];
1091
1092 // we need to clear values (set to 0) because in case the device does
1093 // not get new candidates it idles around but speed display would
1094 // show it as working.
1095 // if we instantly set it to 0 after reading it happens that the
1096 // speed can be shown as zero if the users refreshs to fast.
1097 // therefore, we add a timestamp when a stat was recorded and if its
1098 // to old we will not use it
1099
1100 speed_cnt[device_id] = 0;
1101 speed_ms[device_id] = 0;
1102
1103 for (int i = 0; i < SPEED_CACHE; i++)
1104 {
1105 float rec_ms;
1106
1107 hc_timer_get (device_param->speed_rec[i], rec_ms);
1108
1109 if (rec_ms > SPEED_MAXAGE) continue;
1110
1111 speed_cnt[device_id] += device_param->speed_cnt[i];
1112 speed_ms[device_id] += device_param->speed_ms[i];
1113 }
1114
1115 speed_cnt[device_id] /= SPEED_CACHE;
1116 speed_ms[device_id] /= SPEED_CACHE;
1117 }
1118
1119 float hashes_all_ms = 0;
1120
1121 float hashes_dev_ms[DEVICES_MAX];
1122
1123 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1124 {
1125 hashes_dev_ms[device_id] = 0;
1126
1127 if (speed_ms[device_id])
1128 {
1129 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1130
1131 hashes_all_ms += hashes_dev_ms[device_id];
1132 }
1133 }
1134
1135 /**
1136 * timers
1137 */
1138
1139 float ms_running = 0;
1140
1141 hc_timer_get (data.timer_running, ms_running);
1142
1143 float ms_paused = data.ms_paused;
1144
1145 if (data.devices_status == STATUS_PAUSED)
1146 {
1147 float ms_paused_tmp = 0;
1148
1149 hc_timer_get (data.timer_paused, ms_paused_tmp);
1150
1151 ms_paused += ms_paused_tmp;
1152 }
1153
1154 #ifdef WIN
1155
1156 __time64_t sec_run = ms_running / 1000;
1157
1158 #else
1159
1160 time_t sec_run = ms_running / 1000;
1161
1162 #endif
1163
1164 if (sec_run)
1165 {
1166 char display_run[32];
1167
1168 struct tm tm_run;
1169
1170 struct tm *tmp;
1171
1172 #ifdef WIN
1173
1174 tmp = _gmtime64 (&sec_run);
1175
1176 #else
1177
1178 tmp = gmtime (&sec_run);
1179
1180 #endif
1181
1182 if (tmp != NULL)
1183 {
1184 memcpy (&tm_run, tmp, sizeof (struct tm));
1185
1186 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1187
1188 char *start = ctime (&data.proc_start);
1189
1190 size_t start_len = strlen (start);
1191
1192 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1193 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1194
1195 log_info ("Time.Started...: %s (%s)", start, display_run);
1196 }
1197 }
1198 else
1199 {
1200 log_info ("Time.Started...: 0 secs");
1201 }
1202
1203 /**
1204 * counters
1205 */
1206
1207 uint salts_left = data.salts_cnt - data.salts_done;
1208
1209 if (salts_left == 0) salts_left = 1;
1210
1211 uint64_t progress_total = data.words_cnt * salts_left;
1212
1213 uint64_t all_done = 0;
1214 uint64_t all_rejected = 0;
1215 uint64_t all_restored = 0;
1216
1217 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1218 {
1219 if (salts_left > 1)
1220 {
1221 // otherwise the final cracked status shows 0/XXX progress
1222
1223 if (data.salts_shown[salt_pos] == 1) continue;
1224 }
1225
1226 all_done += data.words_progress_done[salt_pos];
1227 all_rejected += data.words_progress_rejected[salt_pos];
1228 all_restored += data.words_progress_restored[salt_pos];
1229 }
1230
1231 uint64_t progress_cur = all_restored + all_done + all_rejected;
1232 uint64_t progress_end = progress_total;
1233
1234 uint64_t progress_skip = 0;
1235
1236 if (data.skip)
1237 {
1238 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1239
1240 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1241 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1242 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1243 }
1244
1245 if (data.limit)
1246 {
1247 progress_end = MIN (data.limit, data.words_base) * salts_left;
1248
1249 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1250 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1251 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1252 }
1253
1254 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
1255 uint64_t progress_end_relative_skip = progress_end - progress_skip;
1256
1257 float speed_ms_real = ms_running - ms_paused;
1258 uint64_t speed_plains_real = all_done;
1259
1260 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1261 {
1262 if (data.devices_status != STATUS_CRACKED)
1263 {
1264 uint64_t words_per_ms = 0;
1265
1266 if (speed_plains_real && speed_ms_real)
1267 {
1268 words_per_ms = speed_plains_real / speed_ms_real;
1269 }
1270
1271 #ifdef WIN
1272 __time64_t sec_etc = 0;
1273 #else
1274 time_t sec_etc = 0;
1275 #endif
1276
1277 if (words_per_ms)
1278 {
1279 uint64_t progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1280
1281 uint64_t ms_left = progress_left_relative_skip / words_per_ms;
1282
1283 sec_etc = ms_left / 1000;
1284 }
1285
1286 if (sec_etc == 0)
1287 {
1288 log_info ("Time.Estimated.: 0 secs");
1289 }
1290 else if ((uint64_t) sec_etc > ETC_MAX)
1291 {
1292 log_info ("Time.Estimated.: > 10 Years");
1293 }
1294 else
1295 {
1296 char display_etc[32];
1297
1298 struct tm tm_etc;
1299
1300 struct tm *tmp;
1301
1302 #ifdef WIN
1303
1304 tmp = _gmtime64 (&sec_etc);
1305
1306 #else
1307
1308 tmp = gmtime (&sec_etc);
1309
1310 #endif
1311
1312 if (tmp != NULL)
1313 {
1314 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1315
1316 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1317
1318 time_t now;
1319
1320 time (&now);
1321
1322 now += sec_etc;
1323
1324 char *etc = ctime (&now);
1325
1326 size_t etc_len = strlen (etc);
1327
1328 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1329 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1330
1331 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1332 }
1333 }
1334 }
1335 }
1336
1337 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1338 {
1339 char display_dev_cur[16];
1340
1341 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1342
1343 strncpy (display_dev_cur, "0.00", 4);
1344
1345 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1346
1347 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1348 }
1349
1350 char display_all_cur[16];
1351
1352 memset (display_all_cur, 0, sizeof (display_all_cur));
1353
1354 strncpy (display_all_cur, "0.00", 4);
1355
1356 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1357
1358 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1359
1360 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1361 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1362
1363 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);
1364
1365 // crack-per-time
1366
1367 if (data.digests_cnt > 100)
1368 {
1369 time_t now = time (NULL);
1370
1371 int cpt_cur_min = 0;
1372 int cpt_cur_hour = 0;
1373 int cpt_cur_day = 0;
1374
1375 for (int i = 0; i < CPT_BUF; i++)
1376 {
1377 const uint cracked = data.cpt_buf[i].cracked;
1378 const time_t timestamp = data.cpt_buf[i].timestamp;
1379
1380 if ((timestamp + 60) > now)
1381 {
1382 cpt_cur_min += cracked;
1383 }
1384
1385 if ((timestamp + 3600) > now)
1386 {
1387 cpt_cur_hour += cracked;
1388 }
1389
1390 if ((timestamp + 86400) > now)
1391 {
1392 cpt_cur_day += cracked;
1393 }
1394 }
1395
1396 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1397 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1398 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1399
1400 if ((data.cpt_start + 86400) < now)
1401 {
1402 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1403 cpt_cur_min,
1404 cpt_cur_hour,
1405 cpt_cur_day,
1406 cpt_avg_min,
1407 cpt_avg_hour,
1408 cpt_avg_day);
1409 }
1410 else if ((data.cpt_start + 3600) < now)
1411 {
1412 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1413 cpt_cur_min,
1414 cpt_cur_hour,
1415 cpt_avg_min,
1416 cpt_avg_hour,
1417 cpt_avg_day);
1418 }
1419 else if ((data.cpt_start + 60) < now)
1420 {
1421 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1422 cpt_cur_min,
1423 cpt_avg_min,
1424 cpt_avg_hour,
1425 cpt_avg_day);
1426 }
1427 else
1428 {
1429 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1430 cpt_avg_min,
1431 cpt_avg_hour,
1432 cpt_avg_day);
1433 }
1434 }
1435
1436 // Restore point
1437
1438 uint64_t restore_point = get_lowest_words_done ();
1439
1440 uint64_t restore_total = data.words_base;
1441
1442 float percent_restore = 0;
1443
1444 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1445
1446 if (progress_end_relative_skip)
1447 {
1448 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1449 {
1450 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1451 float percent_rejected = 0.0;
1452
1453 if (progress_cur)
1454 {
1455 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1456 }
1457
1458 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);
1459 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1460
1461 if (data.restore_disable == 0)
1462 {
1463 if (percent_finished != 1)
1464 {
1465 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1466 }
1467 }
1468 }
1469 }
1470 else
1471 {
1472 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1473 {
1474 log_info ("Progress.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1475 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1476
1477 if (data.restore_disable == 0)
1478 {
1479 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1480 }
1481 }
1482 else
1483 {
1484 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1485 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1486
1487 // --restore not allowed if stdin is used -- really? why?
1488
1489 //if (data.restore_disable == 0)
1490 //{
1491 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1492 //}
1493 }
1494 }
1495
1496 if (data.gpu_temp_disable == 0)
1497 {
1498 hc_thread_mutex_lock (mux_adl);
1499
1500 for (uint i = 0; i < data.devices_cnt; i++)
1501 {
1502 #define HM_STR_BUF_SIZE 255
1503
1504 if (data.hm_device[i].fan_supported == 1)
1505 {
1506 char temperature[HM_STR_BUF_SIZE];
1507 char utilization[HM_STR_BUF_SIZE];
1508 char fanspeed[HM_STR_BUF_SIZE];
1509
1510 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "%", hm_get_temperature_with_device_id (i));
1511 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "c", hm_get_utilization_with_device_id (i));
1512
1513 if (data.vendor_id == VENDOR_ID_AMD)
1514 {
1515 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (i));
1516 }
1517
1518 if (data.vendor_id == VENDOR_ID_NV)
1519 {
1520 #ifdef LINUX
1521 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (i));
1522 #else
1523 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "rpm", hm_get_fanspeed_with_device_id (i));
1524 #endif
1525 }
1526
1527 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", i + 1, utilization, temperature, fanspeed);
1528 }
1529 else
1530 {
1531 char temperature[HM_STR_BUF_SIZE];
1532 char utilization[HM_STR_BUF_SIZE];
1533
1534 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "%", hm_get_temperature_with_device_id (i));
1535 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "c", hm_get_utilization_with_device_id (i));
1536
1537 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", i + 1, utilization, temperature);
1538 }
1539 }
1540
1541 hc_thread_mutex_unlock (mux_adl);
1542 }
1543 }
1544
1545 static void status_benchmark ()
1546 {
1547 if (data.devices_status == STATUS_INIT) return;
1548 if (data.devices_status == STATUS_STARTING) return;
1549
1550 if (data.words_cnt == 0) return;
1551
1552 uint64_t speed_cnt[DEVICES_MAX];
1553 float speed_ms[DEVICES_MAX];
1554
1555 uint device_id;
1556
1557 for (device_id = 0; device_id < data.devices_cnt; device_id++)
1558 {
1559 hc_device_param_t *device_param = &data.devices_param[device_id];
1560
1561 speed_cnt[device_id] = 0;
1562 speed_ms[device_id] = 0;
1563
1564 for (int i = 0; i < SPEED_CACHE; i++)
1565 {
1566 speed_cnt[device_id] += device_param->speed_cnt[i];
1567 speed_ms[device_id] += device_param->speed_ms[i];
1568 }
1569
1570 speed_cnt[device_id] /= SPEED_CACHE;
1571 speed_ms[device_id] /= SPEED_CACHE;
1572 }
1573
1574 float hashes_all_ms = 0;
1575
1576 float hashes_dev_ms[DEVICES_MAX];
1577
1578 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1579 {
1580 hashes_dev_ms[device_id] = 0;
1581
1582 if (speed_ms[device_id])
1583 {
1584 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1585
1586 hashes_all_ms += hashes_dev_ms[device_id];
1587 }
1588 }
1589
1590 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1591 {
1592 char display_dev_cur[16];
1593
1594 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1595
1596 strncpy (display_dev_cur, "0.00", 4);
1597
1598 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1599
1600 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1601 }
1602
1603 char display_all_cur[16];
1604
1605 memset (display_all_cur, 0, sizeof (display_all_cur));
1606
1607 strncpy (display_all_cur, "0.00", 4);
1608
1609 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1610
1611 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1612 }
1613
1614 /**
1615 * oclHashcat -only- functions
1616 */
1617
1618 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1619 {
1620 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1621 {
1622 if (attack_kern == ATTACK_KERN_STRAIGHT)
1623 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1624 else if (attack_kern == ATTACK_KERN_COMBI)
1625 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1626 else if (attack_kern == ATTACK_KERN_BF)
1627 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1628 }
1629 else
1630 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1631 }
1632
1633 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)
1634 {
1635 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1636 {
1637 if (attack_kern == ATTACK_KERN_STRAIGHT)
1638 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a0.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1639 else if (attack_kern == ATTACK_KERN_COMBI)
1640 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a1.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1641 else if (attack_kern == ATTACK_KERN_BF)
1642 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a3.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1643 }
1644 else
1645 {
1646 snprintf (cached_file, 255, "%s/kernels/%d/m%05d.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1647 }
1648 }
1649
1650 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1651 {
1652 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1653 {
1654 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1655 }
1656 else
1657 {
1658 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1659 }
1660 }
1661
1662 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)
1663 {
1664 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1665 {
1666 snprintf (cached_file, 255, "%s/kernels/%d/markov_be.%s.kernel", profile_dir, vendor_id, device_name_chksum);
1667 }
1668 else
1669 {
1670 snprintf (cached_file, 255, "%s/kernels/%d/markov_le.%s.kernel", profile_dir, vendor_id, device_name_chksum);
1671 }
1672 }
1673
1674 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1675 {
1676 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1677 }
1678
1679 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1680 {
1681 snprintf (cached_file, 255, "%s/kernels/%d/amp_a%d.%s.kernel", profile_dir, vendor_id, attack_kern, device_name_chksum);
1682 }
1683
1684 static uint convert_from_hex (char *line_buf, const uint line_len)
1685 {
1686 if (line_len & 1) return (line_len); // not in hex
1687
1688 if (data.hex_wordlist == 1)
1689 {
1690 uint i;
1691 uint j;
1692
1693 for (i = 0, j = 0; j < line_len; 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 else if (line_len >= 6) // $HEX[] = 6
1703 {
1704 if (line_buf[0] != '$') return (line_len);
1705 if (line_buf[1] != 'H') return (line_len);
1706 if (line_buf[2] != 'E') return (line_len);
1707 if (line_buf[3] != 'X') return (line_len);
1708 if (line_buf[4] != '[') return (line_len);
1709 if (line_buf[line_len - 1] != ']') return (line_len);
1710
1711 uint i;
1712 uint j;
1713
1714 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1715 {
1716 line_buf[i] = hex_to_char (&line_buf[j]);
1717 }
1718
1719 memset (line_buf + i, 0, line_len - i);
1720
1721 return (i);
1722 }
1723
1724 return (line_len);
1725 }
1726
1727 static uint count_lines (FILE *fd)
1728 {
1729 uint cnt = 0;
1730
1731 char *buf = (char *) mymalloc (BUFSIZ);
1732
1733 size_t nread_tmp = 0;
1734
1735 char *ptr = buf;
1736
1737 while (!feof (fd))
1738 {
1739 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1740 nread_tmp = nread;
1741
1742 if (nread < 1) continue;
1743
1744 ptr = buf;
1745
1746 do
1747 {
1748 if (*ptr++ == '\n') cnt++;
1749
1750 } while (nread--);
1751 }
1752
1753 // special case (if last line did not contain a newline char ... at the very end of the file)
1754
1755 if (nread_tmp > 3)
1756 {
1757 ptr -= 2;
1758
1759 if (*ptr != '\n')
1760 {
1761 ptr--;
1762
1763 if (*ptr != '\n') // needed ? different on windows systems?
1764 {
1765 cnt++;
1766 }
1767 }
1768 }
1769
1770 myfree (buf);
1771
1772 return cnt;
1773 }
1774
1775 static void clear_prompt ()
1776 {
1777 fputc ('\r', stdout);
1778
1779 for (size_t i = 0; i < strlen (PROMPT); i++)
1780 {
1781 fputc (' ', stdout);
1782 }
1783
1784 fputc ('\r', stdout);
1785
1786 fflush (stdout);
1787 }
1788
1789 static void gidd_to_pw_t (hc_device_param_t *device_param, const uint64_t gidd, pw_t *pw)
1790 {
1791 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1792 }
1793
1794 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1795 {
1796 char *outfile = data.outfile;
1797 uint quiet = data.quiet;
1798 FILE *pot_fp = data.pot_fp;
1799 uint loopback = data.loopback;
1800 uint debug_mode = data.debug_mode;
1801 char *debug_file = data.debug_file;
1802
1803 char debug_rule_buf[BLOCK_SIZE];
1804 int debug_rule_len = 0; // -1 error
1805 uint debug_plain_len = 0;
1806
1807 unsigned char debug_plain_ptr[BLOCK_SIZE];
1808
1809 // hash
1810
1811 char out_buf[4096]; memset (out_buf, 0, sizeof (out_buf));
1812
1813 ascii_digest (out_buf, salt_pos, digest_pos);
1814
1815 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1816
1817 // plain
1818
1819 plain_t plain;
1820
1821 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1822
1823 uint gidvid = plain.gidvid;
1824 uint il_pos = plain.il_pos;
1825
1826 uint64_t crackpos = device_param->words_off;
1827
1828 uint plain_buf[16];
1829
1830 unsigned char *plain_ptr = (unsigned char *) plain_buf;
1831 unsigned int plain_len = 0;
1832
1833 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1834 {
1835 uint64_t gidd = gidvid;
1836 uint64_t gidm = 0;
1837
1838 pw_t pw;
1839
1840 gidd_to_pw_t (device_param, gidd, &pw);
1841
1842 for (int i = 0, j = gidm; i < 16; i++, j++)
1843 {
1844 plain_buf[i] = pw.hi1[0][j];
1845 }
1846
1847 plain_len = pw.pw_len;
1848
1849 const uint off = device_param->innerloop_pos + il_pos;
1850
1851 if (debug_mode > 0)
1852 {
1853 debug_rule_len = 0;
1854
1855 // save rule
1856 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1857 {
1858 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1859
1860 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1861 }
1862
1863 // save plain
1864 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1865 {
1866 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1867
1868 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1869
1870 debug_plain_len = plain_len;
1871 }
1872 }
1873
1874 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1875
1876 crackpos += gidvid;
1877 crackpos *= data.kernel_rules_cnt;
1878 crackpos += device_param->innerloop_pos + il_pos;
1879
1880 if (plain_len > data.pw_max) plain_len = data.pw_max;
1881 }
1882 else if (data.attack_mode == ATTACK_MODE_COMBI)
1883 {
1884 uint64_t gidd = gidvid;
1885 uint64_t gidm = 0;
1886
1887 pw_t pw;
1888
1889 gidd_to_pw_t (device_param, gidd, &pw);
1890
1891 for (int i = 0, j = gidm; i < 16; i++, j++)
1892 {
1893 plain_buf[i] = pw.hi1[0][j];
1894 }
1895
1896 plain_len = pw.pw_len;
1897
1898 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1899 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1900
1901 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1902 {
1903 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1904 }
1905 else
1906 {
1907 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1908
1909 memcpy (plain_ptr, comb_buf, comb_len);
1910 }
1911
1912 plain_len += comb_len;
1913
1914 crackpos += gidvid;
1915 crackpos *= data.combs_cnt;
1916 crackpos += device_param->innerloop_pos + il_pos;
1917
1918 if (data.pw_max != PW_DICTMAX1)
1919 {
1920 if (plain_len > data.pw_max) plain_len = data.pw_max;
1921 }
1922 }
1923 else if (data.attack_mode == ATTACK_MODE_BF)
1924 {
1925 uint64_t l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1926 uint64_t r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1927
1928 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1929 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1930
1931 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1932 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1933
1934 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1935 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1936
1937 plain_len = data.css_cnt;
1938
1939 crackpos += gidvid;
1940 crackpos *= data.bfs_cnt;
1941 crackpos += device_param->innerloop_pos + il_pos;
1942 }
1943 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1944 {
1945 uint64_t gidd = gidvid;
1946 uint64_t gidm = 0;
1947
1948 pw_t pw;
1949
1950 gidd_to_pw_t (device_param, gidd, &pw);
1951
1952 for (int i = 0, j = gidm; i < 16; i++, j++)
1953 {
1954 plain_buf[i] = pw.hi1[0][j];
1955 }
1956
1957 plain_len = pw.pw_len;
1958
1959 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1960
1961 uint start = 0;
1962 uint stop = device_param->kernel_params_mp_buf32[4];
1963
1964 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1965
1966 plain_len += start + stop;
1967
1968 crackpos += gidvid;
1969 crackpos *= data.combs_cnt;
1970 crackpos += device_param->innerloop_pos + il_pos;
1971
1972 if (data.pw_max != PW_DICTMAX1)
1973 {
1974 if (plain_len > data.pw_max) plain_len = data.pw_max;
1975 }
1976 }
1977 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1978 {
1979 uint64_t gidd = gidvid;
1980 uint64_t gidm = 0;
1981
1982 pw_t pw;
1983
1984 gidd_to_pw_t (device_param, gidd, &pw);
1985
1986 for (int i = 0, j = gidm; i < 16; i++, j++)
1987 {
1988 plain_buf[i] = pw.hi1[0][j];
1989 }
1990
1991 plain_len = pw.pw_len;
1992
1993 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1994
1995 uint start = 0;
1996 uint stop = device_param->kernel_params_mp_buf32[4];
1997
1998 memmove (plain_ptr + stop, plain_ptr, plain_len);
1999
2000 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2001
2002 plain_len += start + stop;
2003
2004 crackpos += gidvid;
2005 crackpos *= data.combs_cnt;
2006 crackpos += device_param->innerloop_pos + il_pos;
2007
2008 if (data.pw_max != PW_DICTMAX1)
2009 {
2010 if (plain_len > data.pw_max) plain_len = data.pw_max;
2011 }
2012 }
2013
2014 if (data.attack_mode == ATTACK_MODE_BF)
2015 {
2016 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2017 {
2018 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2019 {
2020 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2021 {
2022 plain_len = plain_len - data.salts_buf[0].salt_len;
2023 }
2024 }
2025
2026 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2027 {
2028 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2029 {
2030 plain_ptr[j] = plain_ptr[i];
2031 }
2032
2033 plain_len = plain_len / 2;
2034 }
2035 }
2036 }
2037
2038 // if enabled, update also the potfile
2039
2040 if (pot_fp)
2041 {
2042 fprintf (pot_fp, "%s:", out_buf);
2043
2044 format_plain (pot_fp, plain_ptr, plain_len, 1);
2045
2046 fputc ('\n', pot_fp);
2047
2048 fflush (pot_fp);
2049 }
2050
2051 // outfile
2052
2053 FILE *out_fp = NULL;
2054
2055 if (outfile != NULL)
2056 {
2057 if ((out_fp = fopen (outfile, "ab")) == NULL)
2058 {
2059 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2060
2061 out_fp = stdout;
2062 }
2063 }
2064 else
2065 {
2066 out_fp = stdout;
2067
2068 if (quiet == 0) clear_prompt ();
2069 }
2070
2071 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2072
2073 if (outfile != NULL)
2074 {
2075 if (out_fp != stdout)
2076 {
2077 fclose (out_fp);
2078 }
2079 }
2080 else
2081 {
2082 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2083 {
2084 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2085 {
2086 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2087 if (quiet == 0) fflush (stdout);
2088 }
2089 }
2090 }
2091
2092 // loopback
2093
2094 if (loopback)
2095 {
2096 char *loopback_file = data.loopback_file;
2097
2098 FILE *fb_fp = NULL;
2099
2100 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2101 {
2102 format_plain (fb_fp, plain_ptr, plain_len, 1);
2103
2104 fputc ('\n', fb_fp);
2105
2106 fclose (fb_fp);
2107 }
2108 }
2109
2110 // (rule) debug mode
2111
2112 // the next check implies that:
2113 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2114 // - debug_mode > 0
2115
2116 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2117 {
2118 if (debug_rule_len < 0) debug_rule_len = 0;
2119
2120 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2121
2122 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2123
2124 if ((quiet == 0) && (debug_file == NULL))
2125 {
2126 fprintf (stdout, "%s", PROMPT);
2127 fflush (stdout);
2128 }
2129 }
2130 }
2131
2132 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2133 {
2134 salt_t *salt_buf = &data.salts_buf[salt_pos];
2135
2136 int found = 0;
2137
2138 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2139
2140 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2141
2142 if (found == 1)
2143 {
2144 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2145
2146 log_info_nn ("");
2147
2148 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);
2149
2150 uint cpt_cracked = 0;
2151
2152 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2153 {
2154 uint idx = salt_buf->digests_offset + digest_pos;
2155
2156 if (data.digests_shown_tmp[idx] == 0) continue;
2157
2158 if (data.digests_shown[idx] == 1) continue;
2159
2160 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2161 {
2162 data.digests_shown[idx] = 1;
2163
2164 data.digests_done++;
2165
2166 cpt_cracked++;
2167
2168 salt_buf->digests_done++;
2169
2170 if (salt_buf->digests_done == salt_buf->digests_cnt)
2171 {
2172 data.salts_shown[salt_pos] = 1;
2173
2174 data.salts_done++;
2175 }
2176 }
2177
2178 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2179
2180 check_hash (device_param, salt_pos, digest_pos);
2181 }
2182
2183 if (cpt_cracked > 0)
2184 {
2185 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2186 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2187
2188 data.cpt_pos++;
2189
2190 data.cpt_total += cpt_cracked;
2191
2192 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2193 }
2194
2195 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2196 {
2197 // we need to reset cracked state on the device
2198 // otherwise host thinks again and again the hash was cracked
2199 // and returns invalid password each time
2200
2201 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2202
2203 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);
2204 }
2205
2206 memset (device_param->result, 0, device_param->size_results);
2207
2208 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2209 }
2210 }
2211
2212 static void save_hash ()
2213 {
2214 char *hashfile = data.hashfile;
2215
2216 char new_hashfile[256];
2217 char old_hashfile[256];
2218
2219 memset (new_hashfile, 0, sizeof (new_hashfile));
2220 memset (old_hashfile, 0, sizeof (old_hashfile));
2221
2222 snprintf (new_hashfile, 255, "%s.new", hashfile);
2223 snprintf (old_hashfile, 255, "%s.old", hashfile);
2224
2225 unlink (new_hashfile);
2226
2227 char separator = data.separator;
2228
2229 FILE *fp = fopen (new_hashfile, "wb");
2230
2231 if (fp == NULL)
2232 {
2233 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2234
2235 exit (-1);
2236 }
2237
2238 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2239 {
2240 if (data.salts_shown[salt_pos] == 1) continue;
2241
2242 salt_t *salt_buf = &data.salts_buf[salt_pos];
2243
2244 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2245 {
2246 uint idx = salt_buf->digests_offset + digest_pos;
2247
2248 if (data.digests_shown[idx] == 1) continue;
2249
2250 if (data.hash_mode != 2500)
2251 {
2252 char out_buf[4096];
2253
2254 memset (out_buf, 0, sizeof (out_buf));
2255
2256 if (data.username == 1)
2257 {
2258 user_t *user = data.hash_info[idx]->user;
2259
2260 uint i;
2261
2262 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2263
2264 fputc (separator, fp);
2265 }
2266
2267 ascii_digest (out_buf, salt_pos, digest_pos);
2268
2269 fputs (out_buf, fp);
2270
2271 log_out (fp, "");
2272 }
2273 else
2274 {
2275 hccap_t hccap;
2276
2277 to_hccap_t (&hccap, salt_pos, digest_pos);
2278
2279 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2280 }
2281 }
2282 }
2283
2284 fflush (fp);
2285
2286 fclose (fp);
2287
2288 unlink (old_hashfile);
2289
2290 if (rename (hashfile, old_hashfile) != 0)
2291 {
2292 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2293
2294 exit (-1);
2295 }
2296
2297 unlink (hashfile);
2298
2299 if (rename (new_hashfile, hashfile) != 0)
2300 {
2301 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2302
2303 exit (-1);
2304 }
2305
2306 unlink (old_hashfile);
2307 }
2308
2309 static float find_kernel_blocks_div (const uint64_t total_left, const uint kernel_blocks_all)
2310 {
2311 // function called only in case kernel_blocks_all > words_left)
2312
2313 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2314
2315 kernel_blocks_div += kernel_blocks_div / 100;
2316
2317 uint32_t kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2318
2319 while (kernel_blocks_new < total_left)
2320 {
2321 kernel_blocks_div += kernel_blocks_div / 100;
2322
2323 kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2324 }
2325
2326 if (data.quiet == 0)
2327 {
2328 clear_prompt ();
2329
2330 log_info ("");
2331
2332 log_info ("INFO: approaching final keyspace, workload adjusted");
2333
2334 log_info ("");
2335
2336 fprintf (stdout, "%s", PROMPT);
2337
2338 fflush (stdout);
2339 }
2340
2341 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2342
2343 return kernel_blocks_div;
2344 }
2345
2346 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2347 {
2348 uint num_elements = num;
2349
2350 device_param->kernel_params_buf32[30] = data.combs_mode;
2351 device_param->kernel_params_buf32[31] = num;
2352
2353 uint kernel_threads = device_param->kernel_threads;
2354
2355 while (num_elements % kernel_threads) num_elements++;
2356
2357 cl_kernel kernel = NULL;
2358
2359 switch (kern_run)
2360 {
2361 case KERN_RUN_1: kernel = device_param->kernel1; break;
2362 case KERN_RUN_12: kernel = device_param->kernel12; break;
2363 case KERN_RUN_2: kernel = device_param->kernel2; break;
2364 case KERN_RUN_23: kernel = device_param->kernel23; break;
2365 case KERN_RUN_3: kernel = device_param->kernel3; break;
2366 case KERN_RUN_WEAK: kernel = device_param->kernel_weak; break;
2367 }
2368
2369 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2370 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2371 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2372 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2373 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2374 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2375 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2376 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2377 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2378 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2379 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2380
2381 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2382 {
2383 const size_t global_work_size[3] = { num_elements, 32, 1 };
2384 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2385
2386 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2387 }
2388 else
2389 {
2390 const size_t global_work_size[3] = { num_elements, 1, 1 };
2391 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2392
2393 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2394 }
2395
2396 hc_clFlush (device_param->command_queue);
2397
2398 hc_clFinish (device_param->command_queue);
2399 }
2400
2401 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2402 {
2403 uint num_elements = num;
2404
2405 switch (kern_run)
2406 {
2407 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2408 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2409 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2410 }
2411
2412 // causes problems with special threads like in bcrypt
2413 // const uint kernel_threads = device_param->kernel_threads;
2414
2415 const uint kernel_threads = KERNEL_THREADS;
2416
2417 while (num_elements % kernel_threads) num_elements++;
2418
2419 cl_kernel kernel = NULL;
2420
2421 switch (kern_run)
2422 {
2423 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2424 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2425 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2426 }
2427
2428 switch (kern_run)
2429 {
2430 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2431 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2432 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2433 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2434 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2435 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2436 break;
2437 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2438 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2439 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2440 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2441 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2442 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2443 break;
2444 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2445 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2446 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2447 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2448 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2449 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2450 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2451 break;
2452 }
2453
2454 const size_t global_work_size[3] = { num_elements, 1, 1 };
2455 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2456
2457 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2458
2459 hc_clFlush (device_param->command_queue);
2460
2461 hc_clFinish (device_param->command_queue);
2462 }
2463
2464 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2465 {
2466 uint num_elements = num;
2467
2468 uint kernel_threads = device_param->kernel_threads;
2469
2470 while (num_elements % kernel_threads) num_elements++;
2471
2472 cl_kernel kernel = device_param->kernel_tb;
2473
2474 const size_t global_work_size[3] = { num_elements, 1, 1 };
2475 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2476
2477 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2478
2479 hc_clFlush (device_param->command_queue);
2480
2481 hc_clFinish (device_param->command_queue);
2482 }
2483
2484 static void run_kernel_tm (hc_device_param_t *device_param)
2485 {
2486 const uint num_elements = 1024; // fixed
2487
2488 const uint kernel_threads = 32;
2489
2490 cl_kernel kernel = device_param->kernel_tm;
2491
2492 const size_t global_work_size[3] = { num_elements, 1, 1 };
2493 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2494
2495 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2496
2497 hc_clFlush (device_param->command_queue);
2498
2499 hc_clFinish (device_param->command_queue);
2500 }
2501
2502 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2503 {
2504 uint num_elements = num;
2505
2506 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2507 device_param->kernel_params_amp_buf32[6] = num_elements;
2508
2509 // causes problems with special threads like in bcrypt
2510 // const uint kernel_threads = device_param->kernel_threads;
2511
2512 const uint kernel_threads = KERNEL_THREADS;
2513
2514 while (num_elements % kernel_threads) num_elements++;
2515
2516 cl_kernel kernel = device_param->kernel_amp;
2517
2518 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2519 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2520
2521 const size_t global_work_size[3] = { num_elements, 1, 1 };
2522 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2523
2524 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2525
2526 hc_clFlush (device_param->command_queue);
2527
2528 hc_clFinish (device_param->command_queue);
2529 }
2530
2531 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2532 {
2533 if (data.vendor_id == VENDOR_ID_AMD)
2534 {
2535 const cl_uchar zero = 0;
2536
2537 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2538 }
2539
2540 if (data.vendor_id == VENDOR_ID_NV)
2541 {
2542 // NOTE: clEnqueueFillBuffer () always fails with -59
2543 // IOW, it's not supported by Nvidia ForceWare <= 352.21,
2544 // How's that possible, OpenCL 1.2 support is advertised??
2545 // We need to workaround...
2546
2547 #define FILLSZ 0x100000
2548
2549 char *tmp = (char *) mymalloc (FILLSZ);
2550
2551 memset (tmp, 0, FILLSZ);
2552
2553 for (uint i = 0; i < size; i += FILLSZ)
2554 {
2555 const int left = size - i;
2556
2557 const int fillsz = MIN (FILLSZ, left);
2558
2559 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2560 }
2561
2562 myfree (tmp);
2563 }
2564
2565 if (data.vendor_id == VENDOR_ID_GENERIC)
2566 {
2567 const cl_uchar zero = 0;
2568
2569 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2570 }
2571 }
2572
2573 static int run_rule_engine (const int rule_len, const char *rule_buf)
2574 {
2575 if (rule_len == 0)
2576 {
2577 return 0;
2578 }
2579 else if (rule_len == 1)
2580 {
2581 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2582 }
2583
2584 return 1;
2585 }
2586
2587 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2588 {
2589 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2590 {
2591 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);
2592 }
2593 else if (data.attack_kern == ATTACK_KERN_COMBI)
2594 {
2595 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);
2596 }
2597 else if (data.attack_kern == ATTACK_KERN_BF)
2598 {
2599 const uint64_t off = device_param->words_off;
2600
2601 device_param->kernel_params_mp_l_buf64[3] = off;
2602
2603 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2604 }
2605 }
2606
2607 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2608 {
2609 const uint kernel_loops = data.kernel_loops;
2610
2611 // init speed timer
2612
2613 uint speed_pos = device_param->speed_pos;
2614
2615 #ifdef _POSIX
2616 if (device_param->timer_speed.tv_sec == 0)
2617 {
2618 hc_timer_set (&device_param->timer_speed);
2619 }
2620 #endif
2621
2622 #ifdef _WIN
2623 if (device_param->timer_speed.QuadPart == 0)
2624 {
2625 hc_timer_set (&device_param->timer_speed);
2626 }
2627 #endif
2628
2629 // find higest password length, this is for optimization stuff
2630
2631 uint highest_pw_len = 0;
2632
2633 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2634 {
2635 }
2636 else if (data.attack_kern == ATTACK_KERN_COMBI)
2637 {
2638 }
2639 else if (data.attack_kern == ATTACK_KERN_BF)
2640 {
2641 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2642 + device_param->kernel_params_mp_l_buf32[5];
2643 }
2644
2645 // bitslice optimization stuff
2646
2647 if (data.attack_mode == ATTACK_MODE_BF)
2648 {
2649 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2650 {
2651 run_kernel_tb (device_param, pws_cnt);
2652 }
2653 }
2654
2655 // iteration type
2656
2657 uint innerloop_step = 0;
2658 uint innerloop_cnt = 0;
2659
2660 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2661 else innerloop_step = 1;
2662
2663 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2664 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2665 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2666
2667 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2668
2669 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2670 {
2671 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2672
2673 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2674
2675 if (data.devices_status == STATUS_CRACKED) break;
2676 if (data.devices_status == STATUS_ABORTED) break;
2677 if (data.devices_status == STATUS_QUIT) break;
2678 if (data.devices_status == STATUS_BYPASS) break;
2679
2680 if (data.salts_shown[salt_pos] == 1) continue;
2681
2682 salt_t *salt_buf = &data.salts_buf[salt_pos];
2683
2684 device_param->kernel_params_buf32[24] = salt_pos;
2685 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2686 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2687
2688 FILE *combs_fp = device_param->combs_fp;
2689
2690 if (data.attack_mode == ATTACK_MODE_COMBI)
2691 {
2692 rewind (combs_fp);
2693 }
2694
2695 // innerloops
2696
2697 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2698 {
2699 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2700
2701 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2702
2703 if (data.devices_status == STATUS_CRACKED) break;
2704 if (data.devices_status == STATUS_ABORTED) break;
2705 if (data.devices_status == STATUS_QUIT) break;
2706 if (data.devices_status == STATUS_BYPASS) break;
2707
2708 uint innerloop_left = innerloop_cnt - innerloop_pos;
2709
2710 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2711
2712 device_param->innerloop_pos = innerloop_pos;
2713 device_param->innerloop_left = innerloop_left;
2714
2715 device_param->kernel_params_buf32[27] = innerloop_left;
2716
2717 if (innerloop_left == 0) continue;
2718
2719 // initialize amplifiers
2720
2721 if (data.attack_mode == ATTACK_MODE_COMBI)
2722 {
2723 char line_buf[BUFSIZ];
2724
2725 uint i = 0;
2726
2727 while (i < innerloop_left)
2728 {
2729 if (feof (combs_fp)) break;
2730
2731 int line_len = fgetl (combs_fp, line_buf);
2732
2733 if (line_len >= PW_MAX1) continue;
2734
2735 line_len = convert_from_hex (line_buf, line_len);
2736
2737 char *line_buf_new = line_buf;
2738
2739 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2740 {
2741 char rule_buf_out[BLOCK_SIZE];
2742
2743 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2744
2745 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2746
2747 if (rule_len_out < 0)
2748 {
2749 data.words_progress_rejected[salt_pos] += pw_cnt;
2750
2751 continue;
2752 }
2753
2754 line_len = rule_len_out;
2755
2756 line_buf_new = rule_buf_out;
2757 }
2758
2759 line_len = MIN (line_len, PW_DICTMAX);
2760
2761 char *ptr = (char *) device_param->combs_buf[i].i;
2762
2763 memcpy (ptr, line_buf_new, line_len);
2764
2765 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2766
2767 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2768 {
2769 uppercase (ptr, line_len);
2770 }
2771
2772 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2773 {
2774 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2775 {
2776 ptr[line_len] = 0x80;
2777 }
2778
2779 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2780 {
2781 ptr[line_len] = 0x01;
2782 }
2783 }
2784
2785 device_param->combs_buf[i].pw_len = line_len;
2786
2787 i++;
2788 }
2789
2790 for (uint j = i; j < innerloop_left; j++)
2791 {
2792 device_param->combs_buf[j].i[0] = 0;
2793 device_param->combs_buf[j].i[1] = 0;
2794 device_param->combs_buf[j].i[2] = 0;
2795 device_param->combs_buf[j].i[3] = 0;
2796 device_param->combs_buf[j].i[4] = 0;
2797 device_param->combs_buf[j].i[5] = 0;
2798 device_param->combs_buf[j].i[6] = 0;
2799 device_param->combs_buf[j].i[7] = 0;
2800
2801 device_param->combs_buf[j].pw_len = 0;
2802 }
2803
2804 innerloop_left = i;
2805 }
2806 else if (data.attack_mode == ATTACK_MODE_BF)
2807 {
2808 uint64_t off = innerloop_pos;
2809
2810 device_param->kernel_params_mp_r_buf64[3] = off;
2811
2812 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2813 }
2814 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2815 {
2816 uint64_t off = innerloop_pos;
2817
2818 device_param->kernel_params_mp_buf64[3] = off;
2819
2820 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2821 }
2822 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2823 {
2824 uint64_t off = innerloop_pos;
2825
2826 device_param->kernel_params_mp_buf64[3] = off;
2827
2828 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2829 }
2830
2831 // copy amplifiers
2832
2833 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2834 {
2835 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);
2836 }
2837 else if (data.attack_mode == ATTACK_MODE_COMBI)
2838 {
2839 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);
2840 }
2841 else if (data.attack_mode == ATTACK_MODE_BF)
2842 {
2843 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);
2844 }
2845 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2846 {
2847 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);
2848 }
2849 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2850 {
2851 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);
2852 }
2853
2854 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2855 {
2856 if (data.attack_mode == ATTACK_MODE_BF)
2857 {
2858 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2859 {
2860 const uint size_tm = 32 * sizeof (bs_word_t);
2861
2862 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2863
2864 run_kernel_tm (device_param);
2865
2866 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2867 }
2868 }
2869
2870 if (highest_pw_len < 16)
2871 {
2872 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2873 }
2874 else if (highest_pw_len < 32)
2875 {
2876 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2877 }
2878 else
2879 {
2880 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2881 }
2882 }
2883 else
2884 {
2885 run_kernel_amp (device_param, pws_cnt);
2886
2887 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2888
2889 if (data.opts_type & OPTS_TYPE_HOOK12)
2890 {
2891 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2892 }
2893
2894 uint iter = salt_buf->salt_iter;
2895
2896 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2897 {
2898 uint loop_left = iter - loop_pos;
2899
2900 loop_left = MIN (loop_left, kernel_loops);
2901
2902 device_param->kernel_params_buf32[25] = loop_pos;
2903 device_param->kernel_params_buf32[26] = loop_left;
2904
2905 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2906
2907 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2908
2909 if (data.devices_status == STATUS_CRACKED) break;
2910 if (data.devices_status == STATUS_ABORTED) break;
2911 if (data.devices_status == STATUS_QUIT) break;
2912 }
2913
2914 if (data.opts_type & OPTS_TYPE_HOOK23)
2915 {
2916 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2917
2918 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2919
2920 // do something with data
2921
2922 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2923 }
2924
2925 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2926 }
2927
2928 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2929
2930 if (data.devices_status == STATUS_CRACKED) break;
2931 if (data.devices_status == STATUS_ABORTED) break;
2932 if (data.devices_status == STATUS_QUIT) break;
2933
2934 /**
2935 * result
2936 */
2937
2938 hc_thread_mutex_lock (mux_display);
2939
2940 check_cracked (device_param, salt_pos);
2941
2942 hc_thread_mutex_unlock (mux_display);
2943
2944 /**
2945 * progress
2946 */
2947
2948 uint64_t perf_sum_all = (uint64_t) pw_cnt * (uint64_t) innerloop_left;
2949
2950 hc_thread_mutex_lock (mux_counter);
2951
2952 data.words_progress_done[salt_pos] += perf_sum_all;
2953
2954 hc_thread_mutex_unlock (mux_counter);
2955
2956 /**
2957 * speed
2958 */
2959
2960 float speed_ms;
2961
2962 hc_timer_get (device_param->timer_speed, speed_ms);
2963
2964 hc_timer_set (&device_param->timer_speed);
2965
2966 hc_thread_mutex_lock (mux_display);
2967
2968 device_param->speed_cnt[speed_pos] = perf_sum_all;
2969
2970 device_param->speed_ms[speed_pos] = speed_ms;
2971
2972 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2973
2974 hc_thread_mutex_unlock (mux_display);
2975
2976 speed_pos++;
2977
2978 if (speed_pos == SPEED_CACHE)
2979 {
2980 speed_pos = 0;
2981 }
2982 }
2983 }
2984
2985 device_param->speed_pos = speed_pos;
2986 }
2987
2988 static void load_segment (wl_data_t *wl_data, FILE *fd)
2989 {
2990 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2991
2992 wl_data->pos = 0;
2993
2994 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
2995
2996 wl_data->buf[wl_data->cnt] = 0;
2997
2998 if (wl_data->cnt == 0) return;
2999
3000 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3001
3002 while (!feof (fd))
3003 {
3004 if (wl_data->cnt == wl_data->avail)
3005 {
3006 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3007
3008 wl_data->avail += wl_data->incr;
3009 }
3010
3011 const int c = fgetc (fd);
3012
3013 if (c == EOF) break;
3014
3015 wl_data->buf[wl_data->cnt] = (char) c;
3016
3017 wl_data->cnt++;
3018
3019 if (c == '\n') break;
3020 }
3021
3022 // ensure stream ends with a newline
3023
3024 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3025 {
3026 wl_data->cnt++;
3027
3028 wl_data->buf[wl_data->cnt - 1] = '\n';
3029 }
3030
3031 return;
3032 }
3033
3034 static void get_next_word_lm (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3035 {
3036 char *ptr = buf;
3037
3038 for (uint32_t i = 0; i < sz; i++, ptr++)
3039 {
3040 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3041
3042 if (i == 7)
3043 {
3044 *off = i;
3045 *len = i;
3046
3047 return;
3048 }
3049
3050 if (*ptr != '\n') continue;
3051
3052 *off = i + 1;
3053
3054 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3055
3056 *len = i;
3057
3058 return;
3059 }
3060
3061 *off = sz;
3062 *len = sz;
3063 }
3064
3065 static void get_next_word_uc (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3066 {
3067 char *ptr = buf;
3068
3069 for (uint32_t i = 0; i < sz; i++, ptr++)
3070 {
3071 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3072
3073 if (*ptr != '\n') continue;
3074
3075 *off = i + 1;
3076
3077 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3078
3079 *len = i;
3080
3081 return;
3082 }
3083
3084 *off = sz;
3085 *len = sz;
3086 }
3087
3088 static void get_next_word_std (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3089 {
3090 char *ptr = buf;
3091
3092 for (uint32_t i = 0; i < sz; i++, ptr++)
3093 {
3094 if (*ptr != '\n') continue;
3095
3096 *off = i + 1;
3097
3098 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3099
3100 *len = i;
3101
3102 return;
3103 }
3104
3105 *off = sz;
3106 *len = sz;
3107 }
3108
3109 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3110 {
3111 while (wl_data->pos < wl_data->cnt)
3112 {
3113 uint off;
3114 uint len;
3115
3116 char *ptr = wl_data->buf + wl_data->pos;
3117
3118 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3119
3120 wl_data->pos += off;
3121
3122 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3123 {
3124 char rule_buf_out[BLOCK_SIZE];
3125
3126 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3127
3128 int rule_len_out = -1;
3129
3130 if (len < BLOCK_SIZE)
3131 {
3132 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3133 }
3134
3135 if (rule_len_out < 0)
3136 {
3137 continue;
3138 }
3139
3140 if (rule_len_out > PW_MAX)
3141 {
3142 continue;
3143 }
3144 }
3145 else
3146 {
3147 if (len > PW_MAX)
3148 {
3149 continue;
3150 }
3151 }
3152
3153 *out_buf = ptr;
3154 *out_len = len;
3155
3156 return;
3157 }
3158
3159 if (feof (fd))
3160 {
3161 fprintf (stderr, "bug!!\n");
3162
3163 return;
3164 }
3165
3166 load_segment (wl_data, fd);
3167
3168 get_next_word (wl_data, fd, out_buf, out_len);
3169 }
3170
3171 #ifdef _POSIX
3172 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3173 #endif
3174
3175 #ifdef _WIN
3176 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3177 #endif
3178 {
3179 hc_signal (NULL);
3180
3181 dictstat_t d;
3182
3183 d.cnt = 0;
3184
3185 #ifdef _POSIX
3186 fstat (fileno (fd), &d.stat);
3187 #endif
3188
3189 #ifdef _WIN
3190 _fstat64 (fileno (fd), &d.stat);
3191 #endif
3192
3193 d.stat.st_mode = 0;
3194 d.stat.st_nlink = 0;
3195 d.stat.st_uid = 0;
3196 d.stat.st_gid = 0;
3197 d.stat.st_rdev = 0;
3198 d.stat.st_atime = 0;
3199
3200 #ifdef _POSIX
3201 d.stat.st_blksize = 0;
3202 d.stat.st_blocks = 0;
3203 #endif
3204
3205 if (d.stat.st_size == 0) return 0;
3206
3207 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3208
3209 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3210 {
3211 if (d_cache)
3212 {
3213 uint64_t cnt = d_cache->cnt;
3214
3215 uint64_t keyspace = cnt;
3216
3217 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3218 {
3219 keyspace *= data.kernel_rules_cnt;
3220 }
3221 else if (data.attack_kern == ATTACK_KERN_COMBI)
3222 {
3223 keyspace *= data.combs_cnt;
3224 }
3225
3226 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);
3227 if (data.quiet == 0) log_info ("");
3228
3229 hc_signal (sigHandler_default);
3230
3231 return (keyspace);
3232 }
3233 }
3234
3235 time_t now = 0;
3236 time_t prev = 0;
3237
3238 uint64_t comp = 0;
3239 uint64_t cnt = 0;
3240 uint64_t cnt2 = 0;
3241
3242 while (!feof (fd))
3243 {
3244 load_segment (wl_data, fd);
3245
3246 comp += wl_data->cnt;
3247
3248 uint32_t i = 0;
3249
3250 while (i < wl_data->cnt)
3251 {
3252 uint32_t len;
3253 uint32_t off;
3254
3255 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3256
3257 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3258 {
3259 char rule_buf_out[BLOCK_SIZE];
3260
3261 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3262
3263 int rule_len_out = -1;
3264
3265 if (len < BLOCK_SIZE)
3266 {
3267 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3268 }
3269
3270 if (rule_len_out < 0)
3271 {
3272 len = PW_MAX1;
3273 }
3274 else
3275 {
3276 len = rule_len_out;
3277 }
3278 }
3279
3280 if (len < PW_MAX1)
3281 {
3282 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3283 {
3284 cnt += data.kernel_rules_cnt;
3285 }
3286 else if (data.attack_kern == ATTACK_KERN_COMBI)
3287 {
3288 cnt += data.combs_cnt;
3289 }
3290
3291 d.cnt++;
3292 }
3293
3294 i += off;
3295
3296 cnt2++;
3297 }
3298
3299 time (&now);
3300
3301 if ((now - prev) == 0) continue;
3302
3303 float percent = (float) comp / (float) d.stat.st_size;
3304
3305 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);
3306
3307 time (&prev);
3308 }
3309
3310 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);
3311 if (data.quiet == 0) log_info ("");
3312
3313 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3314
3315 hc_signal (sigHandler_default);
3316
3317 return (cnt);
3318 }
3319
3320 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3321 {
3322 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3323 }
3324
3325 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
3326 {
3327 if (data.devices_status == STATUS_BYPASS) return 0;
3328
3329 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3330
3331 uint cache_cnt = pw_cache->cnt;
3332
3333 uint8_t *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3334
3335 memcpy (pw_hc1, pw_buf, pw_len);
3336
3337 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3338
3339 uint pws_cnt = device_param->pws_cnt;
3340
3341 cache_cnt++;
3342
3343 pw_t *pw = device_param->pws_buf + pws_cnt;
3344
3345 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3346
3347 pw->pw_len = pw_len;
3348
3349 pws_cnt++;
3350
3351 device_param->pws_cnt = pws_cnt;
3352 device_param->pw_cnt = pws_cnt * 1;
3353
3354 cache_cnt = 0;
3355
3356 pw_cache->cnt = cache_cnt;
3357
3358 return pws_cnt;
3359 }
3360
3361 static void *thread_monitor (void *p)
3362 {
3363 uint runtime_check = 0;
3364 uint remove_check = 0;
3365 uint status_check = 0;
3366 uint hwmon_check = 0;
3367 uint restore_check = 0;
3368
3369 uint restore_left = data.restore_timer;
3370 uint remove_left = data.remove_timer;
3371 uint status_left = data.status_timer;
3372
3373 // these variables are mainly used for fan control (AMD only)
3374
3375 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3376
3377 // temperature controller "loopback" values
3378
3379 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3380 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3381
3382 int temp_threshold = 1; // degrees celcius
3383
3384 int fan_speed_min = 15; // in percentage
3385 int fan_speed_max = 100;
3386
3387 time_t last_temp_check_time;
3388
3389 uint sleep_time = 1;
3390
3391 if (data.runtime)
3392 {
3393 runtime_check = 1;
3394 }
3395
3396 if (data.restore_timer)
3397 {
3398 restore_check = 1;
3399 }
3400
3401 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3402 {
3403 remove_check = 1;
3404 }
3405
3406 if (data.status == 1)
3407 {
3408 status_check = 1;
3409 }
3410
3411 if (data.gpu_temp_disable == 0)
3412 {
3413 time (&last_temp_check_time);
3414
3415 hwmon_check = 1;
3416 }
3417
3418 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3419 {
3420 return (p);
3421 }
3422
3423 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3424 {
3425 hc_sleep (sleep_time);
3426
3427 if (data.devices_status != STATUS_RUNNING) continue;
3428
3429 if (hwmon_check == 1)
3430 {
3431 hc_thread_mutex_lock (mux_adl);
3432
3433 time_t temp_check_time;
3434
3435 time (&temp_check_time);
3436
3437 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3438
3439 if (Ta == 0) Ta = 1;
3440
3441 for (uint i = 0; i < data.devices_cnt; i++)
3442 {
3443 if ((data.devices_param[i].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3444
3445 const int temperature = hm_get_temperature_with_device_id (i);
3446
3447 if (temperature > (int) data.gpu_temp_abort)
3448 {
3449 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", i + 1);
3450
3451 if (data.devices_status != STATUS_QUIT) myabort ();
3452
3453 break;
3454 }
3455
3456 const int gpu_temp_retain = data.gpu_temp_retain;
3457
3458 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3459 {
3460 if (data.hm_device[i].fan_supported == 1)
3461 {
3462 int temp_cur = temperature;
3463
3464 int temp_diff_new = gpu_temp_retain - temp_cur;
3465
3466 temp_diff_sum[i] = temp_diff_sum[i] + temp_diff_new;
3467
3468 // calculate Ta value (time difference in seconds between the last check and this check)
3469
3470 last_temp_check_time = temp_check_time;
3471
3472 float Kp = 1.8;
3473 float Ki = 0.005;
3474 float Kd = 6;
3475
3476 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3477
3478 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);
3479
3480 if (abs (fan_diff_required) >= temp_threshold)
3481 {
3482 const int fan_speed_cur = hm_get_fanspeed_with_device_id (i);
3483
3484 int fan_speed_level = fan_speed_cur;
3485
3486 if (fan_speed_chgd[i] == 0) fan_speed_level = temp_cur;
3487
3488 int fan_speed_new = fan_speed_level - fan_diff_required;
3489
3490 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3491 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3492
3493 if (fan_speed_new != fan_speed_cur)
3494 {
3495 int freely_change_fan_speed = (fan_speed_chgd[i] == 1);
3496 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3497
3498 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3499 {
3500 hm_set_fanspeed_with_device_id_amd (i, fan_speed_new);
3501
3502 fan_speed_chgd[i] = 1;
3503 }
3504
3505 temp_diff_old[i] = temp_diff_new;
3506 }
3507 }
3508 }
3509 }
3510 }
3511
3512 hc_thread_mutex_unlock (mux_adl);
3513 }
3514
3515 if (restore_check == 1)
3516 {
3517 restore_left--;
3518
3519 if (restore_left == 0)
3520 {
3521 if (data.restore_disable == 0) cycle_restore ();
3522
3523 restore_left = data.restore_timer;
3524 }
3525 }
3526
3527 if ((runtime_check == 1) && (data.runtime_start > 0))
3528 {
3529 time_t runtime_cur;
3530
3531 time (&runtime_cur);
3532
3533 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3534
3535 if (runtime_left <= 0)
3536 {
3537 if (data.benchmark == 0)
3538 {
3539 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3540 }
3541
3542 if (data.devices_status != STATUS_QUIT) myabort ();
3543 }
3544 }
3545
3546 if (remove_check == 1)
3547 {
3548 remove_left--;
3549
3550 if (remove_left == 0)
3551 {
3552 if (data.digests_saved != data.digests_done)
3553 {
3554 data.digests_saved = data.digests_done;
3555
3556 save_hash ();
3557 }
3558
3559 remove_left = data.remove_timer;
3560 }
3561 }
3562
3563 if (status_check == 1)
3564 {
3565 status_left--;
3566
3567 if (status_left == 0)
3568 {
3569 hc_thread_mutex_lock (mux_display);
3570
3571 if (data.quiet == 0) clear_prompt ();
3572
3573 if (data.quiet == 0) log_info ("");
3574
3575 status_display ();
3576
3577 if (data.quiet == 0) log_info ("");
3578
3579 hc_thread_mutex_unlock (mux_display);
3580
3581 status_left = data.status_timer;
3582 }
3583 }
3584 }
3585
3586 myfree (fan_speed_chgd);
3587
3588 myfree (temp_diff_old);
3589 myfree (temp_diff_sum);
3590
3591 p = NULL;
3592
3593 return (p);
3594 }
3595
3596 static void *thread_outfile_remove (void *p)
3597 {
3598 // some hash-dependent constants
3599 char *outfile_dir = data.outfile_check_directory;
3600 uint dgst_size = data.dgst_size;
3601 uint isSalted = data.isSalted;
3602 uint esalt_size = data.esalt_size;
3603 uint hash_mode = data.hash_mode;
3604
3605 uint outfile_check_timer = data.outfile_check_timer;
3606
3607 char separator = data.separator;
3608
3609 // some hash-dependent functions
3610 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3611 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3612
3613 // buffers
3614 hash_t hash_buf;
3615
3616 memset (&hash_buf, 0, sizeof (hash_buf));
3617
3618 hash_buf.digest = mymalloc (dgst_size);
3619
3620 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3621
3622 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3623
3624 uint digest_buf[64];
3625
3626 outfile_data_t *out_info = NULL;
3627
3628 char **out_files = NULL;
3629
3630 time_t folder_mtime = 0;
3631
3632 int out_cnt = 0;
3633
3634 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3635
3636 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3637 {
3638 hc_sleep (1);
3639
3640 if (data.devices_status != STATUS_RUNNING) continue;
3641
3642 check_left--;
3643
3644 if (check_left == 0)
3645 {
3646 struct stat outfile_check_stat;
3647
3648 if (stat (outfile_dir, &outfile_check_stat) == 0)
3649 {
3650 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3651
3652 if (is_dir == 1)
3653 {
3654 if (outfile_check_stat.st_mtime > folder_mtime)
3655 {
3656 char **out_files_new = scan_directory (outfile_dir);
3657
3658 int out_cnt_new = count_dictionaries (out_files_new);
3659
3660 outfile_data_t *out_info_new = NULL;
3661
3662 if (out_cnt_new > 0)
3663 {
3664 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3665
3666 for (int i = 0; i < out_cnt_new; i++)
3667 {
3668 out_info_new[i].file_name = out_files_new[i];
3669
3670 // check if there are files that we have seen/checked before (and not changed)
3671
3672 for (int j = 0; j < out_cnt; j++)
3673 {
3674 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3675 {
3676 struct stat outfile_stat;
3677
3678 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3679 {
3680 if (outfile_stat.st_ctime == out_info[j].ctime)
3681 {
3682 out_info_new[i].ctime = out_info[j].ctime;
3683 out_info_new[i].seek = out_info[j].seek;
3684 }
3685 }
3686 }
3687 }
3688 }
3689 }
3690
3691 local_free (out_info);
3692 local_free (out_files);
3693
3694 out_files = out_files_new;
3695 out_cnt = out_cnt_new;
3696 out_info = out_info_new;
3697
3698 folder_mtime = outfile_check_stat.st_mtime;
3699 }
3700
3701 for (int j = 0; j < out_cnt; j++)
3702 {
3703 FILE *fp = fopen (out_info[j].file_name, "rb");
3704
3705 if (fp != NULL)
3706 {
3707 //hc_thread_mutex_lock (mux_display);
3708
3709 #ifdef _POSIX
3710 struct stat outfile_stat;
3711
3712 fstat (fileno (fp), &outfile_stat);
3713 #endif
3714
3715 #ifdef _WIN
3716 struct stat64 outfile_stat;
3717
3718 _fstat64 (fileno (fp), &outfile_stat);
3719 #endif
3720
3721 if (outfile_stat.st_ctime > out_info[j].ctime)
3722 {
3723 out_info[j].ctime = outfile_stat.st_ctime;
3724 out_info[j].seek = 0;
3725 }
3726
3727 fseek (fp, out_info[j].seek, SEEK_SET);
3728
3729 while (!feof (fp))
3730 {
3731 char line_buf[BUFSIZ];
3732
3733 memset (line_buf, 0, BUFSIZ);
3734
3735 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3736
3737 if (ptr == NULL) break;
3738
3739 int line_len = strlen (line_buf);
3740
3741 if (line_len <= 0) continue;
3742
3743 int iter = MAX_CUT_TRIES;
3744
3745 for (uint i = line_len - 1; i && iter; i--, line_len--)
3746 {
3747 if (line_buf[i] != separator) continue;
3748
3749 int parser_status = PARSER_OK;
3750
3751 if ((hash_mode != 2500) && (hash_mode != 6800))
3752 {
3753 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3754 }
3755
3756 uint found = 0;
3757
3758 if (parser_status == PARSER_OK)
3759 {
3760 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3761 {
3762 if (data.salts_shown[salt_pos] == 1) continue;
3763
3764 salt_t *salt_buf = &data.salts_buf[salt_pos];
3765
3766 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3767 {
3768 uint idx = salt_buf->digests_offset + digest_pos;
3769
3770 if (data.digests_shown[idx] == 1) continue;
3771
3772 uint cracked = 0;
3773
3774 if (hash_mode == 6800)
3775 {
3776 if (i == salt_buf->salt_len)
3777 {
3778 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3779 }
3780 }
3781 else if (hash_mode == 2500)
3782 {
3783 // BSSID : MAC1 : MAC2 (:plain)
3784 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3785 {
3786 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3787
3788 if (!cracked) continue;
3789
3790 // now compare MAC1 and MAC2 too, since we have this additional info
3791 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3792 char *mac2_pos = mac1_pos + 12 + 1;
3793
3794 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3795 wpa_t *wpa = &wpas[salt_pos];
3796
3797 uint pke[25];
3798
3799 char *pke_ptr = (char *) pke;
3800
3801 for (uint i = 0; i < 25; i++)
3802 {
3803 pke[i] = byte_swap_32 (wpa->pke[i]);
3804 }
3805
3806 unsigned char mac1[6];
3807 unsigned char mac2[6];
3808
3809 memcpy (mac1, pke_ptr + 23, 6);
3810 memcpy (mac2, pke_ptr + 29, 6);
3811
3812 // compare hex string(s) vs binary MAC address(es)
3813
3814 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3815 {
3816 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
3817 {
3818 cracked = 0;
3819 break;
3820 }
3821 }
3822
3823 // early skip ;)
3824 if (!cracked) continue;
3825
3826 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3827 {
3828 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
3829 {
3830 cracked = 0;
3831 break;
3832 }
3833 }
3834 }
3835 }
3836 else
3837 {
3838 char *digests_buf_ptr = (char *) data.digests_buf;
3839
3840 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3841
3842 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3843 }
3844
3845 if (cracked == 1)
3846 {
3847 found = 1;
3848
3849 data.digests_shown[idx] = 1;
3850
3851 data.digests_done++;
3852
3853 salt_buf->digests_done++;
3854
3855 if (salt_buf->digests_done == salt_buf->digests_cnt)
3856 {
3857 data.salts_shown[salt_pos] = 1;
3858
3859 data.salts_done++;
3860
3861 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3862 }
3863 }
3864 }
3865
3866 if (data.devices_status == STATUS_CRACKED) break;
3867 }
3868 }
3869
3870 if (found) break;
3871
3872 if (data.devices_status == STATUS_CRACKED) break;
3873
3874 iter--;
3875 }
3876
3877 if (data.devices_status == STATUS_CRACKED) break;
3878 }
3879
3880 out_info[j].seek = ftell (fp);
3881
3882 //hc_thread_mutex_unlock (mux_display);
3883
3884 fclose (fp);
3885 }
3886 }
3887 }
3888 }
3889
3890 check_left = outfile_check_timer;
3891 }
3892 }
3893
3894 if (esalt_size) local_free (hash_buf.esalt);
3895
3896 if (isSalted) local_free (hash_buf.salt);
3897
3898 local_free (hash_buf.digest);
3899
3900 local_free (out_info);
3901
3902 local_free (out_files);
3903
3904 p = NULL;
3905
3906 return (p);
3907 }
3908
3909 static uint get_work (hc_device_param_t *device_param, const uint64_t max)
3910 {
3911 hc_thread_mutex_lock (mux_dispatcher);
3912
3913 const uint64_t words_cur = data.words_cur;
3914 const uint64_t words_base = (data.limit == 0) ? data.words_base : data.limit;
3915
3916 device_param->words_off = words_cur;
3917
3918 const uint64_t words_left = words_base - words_cur;
3919
3920 if (data.kernel_blocks_all > words_left)
3921 {
3922 if (data.kernel_blocks_div == 0)
3923 {
3924 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3925 }
3926 }
3927
3928 if (data.kernel_blocks_div)
3929 {
3930 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3931 {
3932 const uint32_t kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3933 const uint32_t kernel_power_new = kernel_blocks_new;
3934
3935 if (kernel_blocks_new < device_param->kernel_blocks)
3936 {
3937 device_param->kernel_blocks = kernel_blocks_new;
3938 device_param->kernel_power = kernel_power_new;
3939 }
3940 }
3941 }
3942
3943 const uint kernel_blocks = device_param->kernel_blocks;
3944
3945 uint work = MIN (words_left, kernel_blocks);
3946
3947 work = MIN (work, max);
3948
3949 data.words_cur += work;
3950
3951 hc_thread_mutex_unlock (mux_dispatcher);
3952
3953 return work;
3954 }
3955
3956 static void *thread_calc_stdin (void *p)
3957 {
3958 hc_device_param_t *device_param = (hc_device_param_t *) p;
3959
3960 const uint attack_kern = data.attack_kern;
3961
3962 const uint kernel_blocks = device_param->kernel_blocks;
3963
3964 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3965 {
3966 hc_thread_mutex_lock (mux_dispatcher);
3967
3968 if (feof (stdin) != 0)
3969 {
3970 hc_thread_mutex_unlock (mux_dispatcher);
3971
3972 break;
3973 }
3974
3975 uint words_cur = 0;
3976
3977 while (words_cur < kernel_blocks)
3978 {
3979 char buf[BUFSIZ];
3980
3981 char *line_buf = fgets (buf, sizeof (buf), stdin);
3982
3983 if (line_buf == NULL) break;
3984
3985 uint line_len = in_superchop (line_buf);
3986
3987 line_len = convert_from_hex (line_buf, line_len);
3988
3989 // post-process rule engine
3990
3991 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3992 {
3993 char rule_buf_out[BLOCK_SIZE];
3994
3995 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3996
3997 int rule_len_out = -1;
3998
3999 if (line_len < BLOCK_SIZE)
4000 {
4001 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4002 }
4003
4004 if (rule_len_out < 0) continue;
4005
4006 line_buf = rule_buf_out;
4007 line_len = rule_len_out;
4008 }
4009
4010 if (line_len > PW_MAX)
4011 {
4012 continue;
4013 }
4014
4015 if (attack_kern == ATTACK_KERN_STRAIGHT)
4016 {
4017 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4018 {
4019 hc_thread_mutex_lock (mux_counter);
4020
4021 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4022 {
4023 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4024 }
4025
4026 hc_thread_mutex_unlock (mux_counter);
4027
4028 continue;
4029 }
4030 }
4031 else if (attack_kern == ATTACK_KERN_COMBI)
4032 {
4033 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4034 // since we still need to combine the plains
4035
4036 if (line_len > data.pw_max)
4037 {
4038 hc_thread_mutex_lock (mux_counter);
4039
4040 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4041 {
4042 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4043 }
4044
4045 hc_thread_mutex_unlock (mux_counter);
4046
4047 continue;
4048 }
4049 }
4050
4051 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4052
4053 words_cur++;
4054
4055 if (data.devices_status == STATUS_CRACKED) break;
4056 if (data.devices_status == STATUS_ABORTED) break;
4057 if (data.devices_status == STATUS_QUIT) break;
4058 if (data.devices_status == STATUS_BYPASS) break;
4059 }
4060
4061 hc_thread_mutex_unlock (mux_dispatcher);
4062
4063 if (data.devices_status == STATUS_CRACKED) break;
4064 if (data.devices_status == STATUS_ABORTED) break;
4065 if (data.devices_status == STATUS_QUIT) break;
4066 if (data.devices_status == STATUS_BYPASS) break;
4067
4068 // we need 2 flushing because we have two independant caches and it can occur
4069 // that one buffer is already at threshold plus for that length also exists
4070 // more data in the 2nd buffer so it would overflow
4071
4072 // flush session 1
4073
4074 {
4075 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4076 {
4077 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4078
4079 const uint pw_cache_cnt = pw_cache->cnt;
4080
4081 if (pw_cache_cnt == 0) continue;
4082
4083 pw_cache->cnt = 0;
4084
4085 uint pws_cnt = device_param->pws_cnt;
4086
4087 pw_t *pw = device_param->pws_buf + pws_cnt;
4088
4089 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4090
4091 pw->pw_len = pw_len;
4092
4093 uint pw_cnt = device_param->pw_cnt;
4094
4095 pw_cnt += pw_cache_cnt;
4096
4097 device_param->pw_cnt = pw_cnt;
4098
4099 pws_cnt++;
4100
4101 device_param->pws_cnt = pws_cnt;
4102
4103 if (pws_cnt == device_param->kernel_power_user) break;
4104 }
4105
4106 const uint pw_cnt = device_param->pw_cnt;
4107 const uint pws_cnt = device_param->pws_cnt;
4108
4109 if (pws_cnt)
4110 {
4111 run_copy (device_param, pws_cnt);
4112
4113 run_cracker (device_param, pw_cnt, pws_cnt);
4114
4115 device_param->pw_cnt = 0;
4116 device_param->pws_cnt = 0;
4117 }
4118 }
4119
4120 // flush session 2
4121
4122 {
4123 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4124 {
4125 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4126
4127 const uint pw_cache_cnt = pw_cache->cnt;
4128
4129 if (pw_cache_cnt == 0) continue;
4130
4131 pw_cache->cnt = 0;
4132
4133 uint pws_cnt = device_param->pws_cnt;
4134
4135 pw_t *pw = device_param->pws_buf + pws_cnt;
4136
4137 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4138
4139 pw->pw_len = pw_len;
4140
4141 uint pw_cnt = device_param->pw_cnt;
4142
4143 pw_cnt += pw_cache_cnt;
4144
4145 device_param->pw_cnt = pw_cnt;
4146
4147 pws_cnt++;
4148
4149 device_param->pws_cnt = pws_cnt;
4150 }
4151
4152 const uint pw_cnt = device_param->pw_cnt;
4153 const uint pws_cnt = device_param->pws_cnt;
4154
4155 if (pws_cnt)
4156 {
4157 run_copy (device_param, pws_cnt);
4158
4159 run_cracker (device_param, pw_cnt, pws_cnt);
4160
4161 device_param->pw_cnt = 0;
4162 device_param->pws_cnt = 0;
4163 }
4164 }
4165 }
4166
4167 return NULL;
4168 }
4169
4170 static void *thread_calc (void *p)
4171 {
4172 hc_device_param_t *device_param = (hc_device_param_t *) p;
4173
4174 const uint attack_mode = data.attack_mode;
4175 const uint attack_kern = data.attack_kern;
4176
4177 if (attack_mode == ATTACK_MODE_BF)
4178 {
4179 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4180 {
4181 const uint work = get_work (device_param, -1);
4182
4183 if (work == 0) break;
4184
4185 const uint64_t words_off = device_param->words_off;
4186 const uint64_t words_fin = words_off + work;
4187
4188 const uint pw_cnt = work;
4189 const uint pws_cnt = work;
4190
4191 device_param->pw_cnt = pw_cnt;
4192 device_param->pws_cnt = pws_cnt;
4193
4194 if (pws_cnt)
4195 {
4196 run_copy (device_param, pws_cnt);
4197
4198 run_cracker (device_param, pw_cnt, pws_cnt);
4199
4200 device_param->pw_cnt = 0;
4201 device_param->pws_cnt = 0;
4202 }
4203
4204 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4205
4206 if (data.devices_status == STATUS_CRACKED) break;
4207 if (data.devices_status == STATUS_ABORTED) break;
4208 if (data.devices_status == STATUS_QUIT) break;
4209 if (data.devices_status == STATUS_BYPASS) break;
4210
4211 device_param->words_done = words_fin;
4212 }
4213 }
4214 else
4215 {
4216 const uint segment_size = data.segment_size;
4217
4218 char *dictfile = data.dictfile;
4219
4220 if (attack_mode == ATTACK_MODE_COMBI)
4221 {
4222 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4223 {
4224 dictfile = data.dictfile2;
4225 }
4226 }
4227
4228 FILE *fd = fopen (dictfile, "rb");
4229
4230 if (fd == NULL)
4231 {
4232 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4233
4234 return NULL;
4235 }
4236
4237 if (attack_mode == ATTACK_MODE_COMBI)
4238 {
4239 const uint combs_mode = data.combs_mode;
4240
4241 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4242 {
4243 const char *dictfilec = data.dictfile2;
4244
4245 FILE *combs_fp = fopen (dictfilec, "rb");
4246
4247 if (combs_fp == NULL)
4248 {
4249 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4250
4251 fclose (fd);
4252
4253 return NULL;
4254 }
4255
4256 device_param->combs_fp = combs_fp;
4257 }
4258 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4259 {
4260 const char *dictfilec = data.dictfile;
4261
4262 FILE *combs_fp = fopen (dictfilec, "rb");
4263
4264 if (combs_fp == NULL)
4265 {
4266 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4267
4268 fclose (fd);
4269
4270 return NULL;
4271 }
4272
4273 device_param->combs_fp = combs_fp;
4274 }
4275 }
4276
4277 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4278
4279 wl_data->buf = (char *) mymalloc (segment_size);
4280 wl_data->avail = segment_size;
4281 wl_data->incr = segment_size;
4282 wl_data->cnt = 0;
4283 wl_data->pos = 0;
4284
4285 uint64_t words_cur = 0;
4286
4287 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4288 {
4289 uint64_t words_off = 0;
4290 uint64_t words_fin = 0;
4291
4292 uint64_t max = -1;
4293
4294 while (max)
4295 {
4296 const uint work = get_work (device_param, max);
4297
4298 if (work == 0) break;
4299
4300 words_off = device_param->words_off;
4301 words_fin = words_off + work;
4302
4303 char *line_buf;
4304 uint line_len;
4305
4306 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4307
4308 max = 0;
4309
4310 for ( ; words_cur < words_fin; words_cur++)
4311 {
4312 get_next_word (wl_data, fd, &line_buf, &line_len);
4313
4314 line_len = convert_from_hex (line_buf, line_len);
4315
4316 // post-process rule engine
4317
4318 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4319 {
4320 char rule_buf_out[BLOCK_SIZE];
4321
4322 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4323
4324 int rule_len_out = -1;
4325
4326 if (line_len < BLOCK_SIZE)
4327 {
4328 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4329 }
4330
4331 if (rule_len_out < 0) continue;
4332
4333 line_buf = rule_buf_out;
4334 line_len = rule_len_out;
4335 }
4336
4337 if (attack_kern == ATTACK_KERN_STRAIGHT)
4338 {
4339 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4340 {
4341 max++;
4342
4343 hc_thread_mutex_lock (mux_counter);
4344
4345 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4346 {
4347 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4348 }
4349
4350 hc_thread_mutex_unlock (mux_counter);
4351
4352 continue;
4353 }
4354 }
4355 else if (attack_kern == ATTACK_KERN_COMBI)
4356 {
4357 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4358 // since we still need to combine the plains
4359
4360 if (line_len > data.pw_max)
4361 {
4362 max++;
4363
4364 hc_thread_mutex_lock (mux_counter);
4365
4366 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4367 {
4368 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4369 }
4370
4371 hc_thread_mutex_unlock (mux_counter);
4372
4373 continue;
4374 }
4375 }
4376
4377 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4378
4379 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4380
4381 if (data.devices_status == STATUS_CRACKED) break;
4382 if (data.devices_status == STATUS_ABORTED) break;
4383 if (data.devices_status == STATUS_QUIT) break;
4384 if (data.devices_status == STATUS_BYPASS) break;
4385 }
4386
4387 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4388
4389 if (data.devices_status == STATUS_CRACKED) break;
4390 if (data.devices_status == STATUS_ABORTED) break;
4391 if (data.devices_status == STATUS_QUIT) break;
4392 if (data.devices_status == STATUS_BYPASS) break;
4393 }
4394
4395 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4396
4397 if (data.devices_status == STATUS_CRACKED) break;
4398 if (data.devices_status == STATUS_ABORTED) break;
4399 if (data.devices_status == STATUS_QUIT) break;
4400 if (data.devices_status == STATUS_BYPASS) break;
4401
4402 // we need 2 flushing because we have two independant caches and it can occur
4403 // that one buffer is already at threshold plus for that length also exists
4404 // more data in the 2nd buffer so it would overflow
4405
4406 //
4407 // flush session 1
4408 //
4409
4410 {
4411 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4412 {
4413 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4414
4415 const uint pw_cache_cnt = pw_cache->cnt;
4416
4417 if (pw_cache_cnt == 0) continue;
4418
4419 pw_cache->cnt = 0;
4420
4421 uint pws_cnt = device_param->pws_cnt;
4422
4423 pw_t *pw = device_param->pws_buf + pws_cnt;
4424
4425 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4426
4427 pw->pw_len = pw_len;
4428
4429 uint pw_cnt = device_param->pw_cnt;
4430
4431 pw_cnt += pw_cache_cnt;
4432
4433 device_param->pw_cnt = pw_cnt;
4434
4435 pws_cnt++;
4436
4437 device_param->pws_cnt = pws_cnt;
4438
4439 if (pws_cnt == device_param->kernel_power_user) break;
4440 }
4441
4442 const uint pw_cnt = device_param->pw_cnt;
4443 const uint pws_cnt = device_param->pws_cnt;
4444
4445 if (pws_cnt)
4446 {
4447 run_copy (device_param, pws_cnt);
4448
4449 run_cracker (device_param, pw_cnt, pws_cnt);
4450
4451 device_param->pw_cnt = 0;
4452 device_param->pws_cnt = 0;
4453 }
4454
4455 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4456
4457 if (data.devices_status == STATUS_CRACKED) break;
4458 if (data.devices_status == STATUS_ABORTED) break;
4459 if (data.devices_status == STATUS_QUIT) break;
4460 if (data.devices_status == STATUS_BYPASS) break;
4461 }
4462
4463 //
4464 // flush session 2
4465 //
4466
4467 {
4468 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4469 {
4470 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4471
4472 const uint pw_cache_cnt = pw_cache->cnt;
4473
4474 if (pw_cache_cnt == 0) continue;
4475
4476 pw_cache->cnt = 0;
4477
4478 uint pws_cnt = device_param->pws_cnt;
4479
4480 pw_t *pw = device_param->pws_buf + pws_cnt;
4481
4482 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4483
4484 pw->pw_len = pw_len;
4485
4486 uint pw_cnt = device_param->pw_cnt;
4487
4488 pw_cnt += pw_cache_cnt;
4489
4490 device_param->pw_cnt = pw_cnt;
4491
4492 pws_cnt++;
4493
4494 device_param->pws_cnt = pws_cnt;
4495 }
4496
4497 const uint pw_cnt = device_param->pw_cnt;
4498 const uint pws_cnt = device_param->pws_cnt;
4499
4500 if (pws_cnt)
4501 {
4502 run_copy (device_param, pws_cnt);
4503
4504 run_cracker (device_param, pw_cnt, pws_cnt);
4505
4506 device_param->pw_cnt = 0;
4507 device_param->pws_cnt = 0;
4508 }
4509
4510 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4511
4512 if (data.devices_status == STATUS_CRACKED) break;
4513 if (data.devices_status == STATUS_ABORTED) break;
4514 if (data.devices_status == STATUS_QUIT) break;
4515 if (data.devices_status == STATUS_BYPASS) break;
4516 }
4517
4518 if (words_fin == 0) break;
4519
4520 device_param->words_done = words_fin;
4521 }
4522
4523 if (attack_mode == ATTACK_MODE_COMBI)
4524 {
4525 fclose (device_param->combs_fp);
4526 }
4527
4528 free (wl_data->buf);
4529 free (wl_data);
4530
4531 fclose (fd);
4532 }
4533
4534 return NULL;
4535 }
4536
4537 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4538 {
4539 salt_t *salt_buf = &data.salts_buf[salt_pos];
4540
4541 device_param->kernel_params_buf32[24] = salt_pos;
4542 device_param->kernel_params_buf32[27] = 1;
4543 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4544 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4545 device_param->kernel_params_buf32[30] = 0;
4546 device_param->kernel_params_buf32[31] = 1;
4547
4548 char *dictfile_old = data.dictfile;
4549 char *dictfile2_old = data.dictfile2;
4550 char *mask_old = data.mask;
4551 int attack_mode_old = data.attack_mode;
4552
4553 const char *weak_hash_check = "weak-hash-check";
4554
4555 data.dictfile = (char *) weak_hash_check;
4556 data.dictfile2 = (char *) weak_hash_check;
4557 data.mask = (char *) weak_hash_check;
4558 data.attack_mode = ATTACK_MODE_STRAIGHT;
4559
4560 /**
4561 * run the kernel
4562 */
4563
4564 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4565 {
4566 run_kernel (KERN_RUN_WEAK, device_param, 1);
4567 }
4568 else
4569 {
4570 run_kernel (KERN_RUN_1, device_param, 1);
4571
4572 const uint iter = salt_buf->salt_iter;
4573
4574 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4575 {
4576 uint loop_left = iter - loop_pos;
4577
4578 loop_left = MIN (loop_left, kernel_loops);
4579
4580 device_param->kernel_params_buf32[25] = loop_pos;
4581 device_param->kernel_params_buf32[26] = loop_left;
4582
4583 run_kernel (KERN_RUN_2, device_param, 1);
4584 }
4585
4586 run_kernel (KERN_RUN_3, device_param, 1);
4587 }
4588
4589 /**
4590 * result
4591 */
4592
4593 check_cracked (device_param, salt_pos);
4594
4595 /**
4596 * cleanup
4597 */
4598
4599 device_param->kernel_params_buf32[24] = 0;
4600 device_param->kernel_params_buf32[25] = 0;
4601 device_param->kernel_params_buf32[26] = 0;
4602 device_param->kernel_params_buf32[27] = 0;
4603 device_param->kernel_params_buf32[28] = 0;
4604 device_param->kernel_params_buf32[29] = 0;
4605 device_param->kernel_params_buf32[30] = 0;
4606 device_param->kernel_params_buf32[31] = 0;
4607
4608 data.dictfile = dictfile_old;
4609 data.dictfile2 = dictfile2_old;
4610 data.mask = mask_old;
4611 data.attack_mode = attack_mode_old;
4612 }
4613
4614 // hlfmt hashcat
4615
4616 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4617 {
4618 if (data.username == 0)
4619 {
4620 *hashbuf_pos = line_buf;
4621 *hashbuf_len = line_len;
4622 }
4623 else
4624 {
4625 char *pos = line_buf;
4626 int len = line_len;
4627
4628 for (int i = 0; i < line_len; i++, pos++, len--)
4629 {
4630 if (line_buf[i] == data.separator)
4631 {
4632 pos++;
4633
4634 len--;
4635
4636 break;
4637 }
4638 }
4639
4640 *hashbuf_pos = pos;
4641 *hashbuf_len = len;
4642 }
4643 }
4644
4645 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4646 {
4647 char *pos = NULL;
4648 int len = 0;
4649
4650 int sep_cnt = 0;
4651
4652 for (int i = 0; i < line_len; i++)
4653 {
4654 if (line_buf[i] == data.separator)
4655 {
4656 sep_cnt++;
4657
4658 continue;
4659 }
4660
4661 if (sep_cnt == 0)
4662 {
4663 if (pos == NULL) pos = line_buf + i;
4664
4665 len++;
4666 }
4667 }
4668
4669 *userbuf_pos = pos;
4670 *userbuf_len = len;
4671 }
4672
4673 // hlfmt pwdump
4674
4675 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4676 {
4677 int sep_cnt = 0;
4678
4679 int sep2_len = 0;
4680 int sep3_len = 0;
4681
4682 for (int i = 0; i < line_len; i++)
4683 {
4684 if (line_buf[i] == ':')
4685 {
4686 sep_cnt++;
4687
4688 continue;
4689 }
4690
4691 if (sep_cnt == 2) sep2_len++;
4692 if (sep_cnt == 3) sep3_len++;
4693 }
4694
4695 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4696
4697 return 0;
4698 }
4699
4700 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4701 {
4702 char *pos = NULL;
4703 int len = 0;
4704
4705 int sep_cnt = 0;
4706
4707 for (int i = 0; i < line_len; i++)
4708 {
4709 if (line_buf[i] == ':')
4710 {
4711 sep_cnt++;
4712
4713 continue;
4714 }
4715
4716 if (data.hash_mode == 1000)
4717 {
4718 if (sep_cnt == 3)
4719 {
4720 if (pos == NULL) pos = line_buf + i;
4721
4722 len++;
4723 }
4724 }
4725 else if (data.hash_mode == 3000)
4726 {
4727 if (sep_cnt == 2)
4728 {
4729 if (pos == NULL) pos = line_buf + i;
4730
4731 len++;
4732 }
4733 }
4734 }
4735
4736 *hashbuf_pos = pos;
4737 *hashbuf_len = len;
4738 }
4739
4740 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4741 {
4742 char *pos = NULL;
4743 int len = 0;
4744
4745 int sep_cnt = 0;
4746
4747 for (int i = 0; i < line_len; i++)
4748 {
4749 if (line_buf[i] == ':')
4750 {
4751 sep_cnt++;
4752
4753 continue;
4754 }
4755
4756 if (sep_cnt == 0)
4757 {
4758 if (pos == NULL) pos = line_buf + i;
4759
4760 len++;
4761 }
4762 }
4763
4764 *userbuf_pos = pos;
4765 *userbuf_len = len;
4766 }
4767
4768 // hlfmt passwd
4769
4770 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4771 {
4772 int sep_cnt = 0;
4773
4774 char sep5_first = 0;
4775 char sep6_first = 0;
4776
4777 for (int i = 0; i < line_len; i++)
4778 {
4779 if (line_buf[i] == ':')
4780 {
4781 sep_cnt++;
4782
4783 continue;
4784 }
4785
4786 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4787 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4788 }
4789
4790 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4791
4792 return 0;
4793 }
4794
4795 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4796 {
4797 char *pos = NULL;
4798 int len = 0;
4799
4800 int sep_cnt = 0;
4801
4802 for (int i = 0; i < line_len; i++)
4803 {
4804 if (line_buf[i] == ':')
4805 {
4806 sep_cnt++;
4807
4808 continue;
4809 }
4810
4811 if (sep_cnt == 1)
4812 {
4813 if (pos == NULL) pos = line_buf + i;
4814
4815 len++;
4816 }
4817 }
4818
4819 *hashbuf_pos = pos;
4820 *hashbuf_len = len;
4821 }
4822
4823 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4824 {
4825 char *pos = NULL;
4826 int len = 0;
4827
4828 int sep_cnt = 0;
4829
4830 for (int i = 0; i < line_len; i++)
4831 {
4832 if (line_buf[i] == ':')
4833 {
4834 sep_cnt++;
4835
4836 continue;
4837 }
4838
4839 if (sep_cnt == 0)
4840 {
4841 if (pos == NULL) pos = line_buf + i;
4842
4843 len++;
4844 }
4845 }
4846
4847 *userbuf_pos = pos;
4848 *userbuf_len = len;
4849 }
4850
4851 // hlfmt shadow
4852
4853 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4854 {
4855 int sep_cnt = 0;
4856
4857 for (int i = 0; i < line_len; i++)
4858 {
4859 if (line_buf[i] == ':') sep_cnt++;
4860 }
4861
4862 if (sep_cnt == 8) return 1;
4863
4864 return 0;
4865 }
4866
4867 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4868 {
4869 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4870 }
4871
4872 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4873 {
4874 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4875 }
4876
4877 // hlfmt main
4878
4879 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4880 {
4881 switch (hashfile_format)
4882 {
4883 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4884 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4885 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4886 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4887 }
4888 }
4889
4890 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4891 {
4892 switch (hashfile_format)
4893 {
4894 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4895 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4896 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4897 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4898 }
4899 }
4900
4901 static uint hlfmt_detect (FILE *fp, uint max_check)
4902 {
4903 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4904
4905 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4906 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4907
4908 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4909
4910 uint num_check = 0;
4911
4912 while (!feof (fp))
4913 {
4914 char line_buf[BUFSIZ];
4915
4916 int line_len = fgetl (fp, line_buf);
4917
4918 if (line_len == 0) continue;
4919
4920 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4921 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4922 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4923
4924 if (num_check == max_check) break;
4925
4926 num_check++;
4927 }
4928
4929 uint hashlist_format = HLFMT_HASHCAT;
4930
4931 for (int i = 1; i < HLFMTS_CNT; i++)
4932 {
4933 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4934
4935 hashlist_format = i;
4936 }
4937
4938 free (formats_cnt);
4939
4940 return hashlist_format;
4941 }
4942
4943 /**
4944 * some further helper function
4945 */
4946
4947 // wrapper around mymalloc for ADL
4948
4949 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4950 {
4951 return mymalloc (iSize);
4952 }
4953
4954 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const uint64_t collisions_max)
4955 {
4956 uint64_t collisions = 0;
4957
4958 const uint dgst_pos0 = data.dgst_pos0;
4959 const uint dgst_pos1 = data.dgst_pos1;
4960 const uint dgst_pos2 = data.dgst_pos2;
4961 const uint dgst_pos3 = data.dgst_pos3;
4962
4963 memset (bitmap_a, 0, bitmap_size);
4964 memset (bitmap_b, 0, bitmap_size);
4965 memset (bitmap_c, 0, bitmap_size);
4966 memset (bitmap_d, 0, bitmap_size);
4967
4968 for (uint i = 0; i < digests_cnt; i++)
4969 {
4970 uint *digest_ptr = (uint *) digests_buf_ptr;
4971
4972 digests_buf_ptr += dgst_size;
4973
4974 const uint val0 = 1 << (digest_ptr[dgst_pos0] & 0x1f);
4975 const uint val1 = 1 << (digest_ptr[dgst_pos1] & 0x1f);
4976 const uint val2 = 1 << (digest_ptr[dgst_pos2] & 0x1f);
4977 const uint val3 = 1 << (digest_ptr[dgst_pos3] & 0x1f);
4978
4979 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4980 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4981 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4982 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4983
4984 if (bitmap_a[idx0] & val0) collisions++;
4985 if (bitmap_b[idx1] & val1) collisions++;
4986 if (bitmap_c[idx2] & val2) collisions++;
4987 if (bitmap_d[idx3] & val3) collisions++;
4988
4989 bitmap_a[idx0] |= val0;
4990 bitmap_b[idx1] |= val1;
4991 bitmap_c[idx2] |= val2;
4992 bitmap_d[idx3] |= val3;
4993
4994 if (collisions >= collisions_max) return 0x7fffffff;
4995 }
4996
4997 return collisions;
4998 }
4999
5000 /**
5001 * main
5002 */
5003
5004 int main (int argc, char **argv)
5005 {
5006 /**
5007 * To help users a bit
5008 */
5009
5010 char *compute = getenv ("COMPUTE");
5011
5012 if (compute)
5013 {
5014 char display[100];
5015
5016 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5017
5018 putenv (display);
5019 }
5020 else
5021 {
5022 if (getenv ("DISPLAY") == NULL)
5023 putenv ((char *) "DISPLAY=:0");
5024 }
5025
5026 /*
5027 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5028 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5029
5030 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5031 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5032 */
5033
5034 /**
5035 * Real init
5036 */
5037
5038 memset (&data, 0, sizeof (hc_global_data_t));
5039
5040 time_t proc_start;
5041
5042 time (&proc_start);
5043
5044 data.proc_start = proc_start;
5045
5046 int myargc = argc;
5047 char **myargv = argv;
5048
5049 hc_thread_mutex_init (mux_dispatcher);
5050 hc_thread_mutex_init (mux_counter);
5051 hc_thread_mutex_init (mux_display);
5052 hc_thread_mutex_init (mux_adl);
5053
5054 /**
5055 * commandline parameters
5056 */
5057
5058 uint usage = USAGE;
5059 uint version = VERSION;
5060 uint quiet = QUIET;
5061 uint benchmark = BENCHMARK;
5062 uint benchmark_mode = BENCHMARK_MODE;
5063 uint show = SHOW;
5064 uint left = LEFT;
5065 uint username = USERNAME;
5066 uint remove = REMOVE;
5067 uint remove_timer = REMOVE_TIMER;
5068 uint64_t skip = SKIP;
5069 uint64_t limit = LIMIT;
5070 uint keyspace = KEYSPACE;
5071 uint potfile_disable = POTFILE_DISABLE;
5072 uint debug_mode = DEBUG_MODE;
5073 char *debug_file = NULL;
5074 char *induction_dir = NULL;
5075 char *outfile_check_dir = NULL;
5076 uint force = FORCE;
5077 uint runtime = RUNTIME;
5078 uint hash_mode = HASH_MODE;
5079 uint attack_mode = ATTACK_MODE;
5080 uint markov_disable = MARKOV_DISABLE;
5081 uint markov_classic = MARKOV_CLASSIC;
5082 uint markov_threshold = MARKOV_THRESHOLD;
5083 char *markov_hcstat = NULL;
5084 char *outfile = NULL;
5085 uint outfile_format = OUTFILE_FORMAT;
5086 uint outfile_autohex = OUTFILE_AUTOHEX;
5087 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5088 uint restore = RESTORE;
5089 uint restore_timer = RESTORE_TIMER;
5090 uint restore_disable = RESTORE_DISABLE;
5091 uint status = STATUS;
5092 uint status_timer = STATUS_TIMER;
5093 uint status_automat = STATUS_AUTOMAT;
5094 uint loopback = LOOPBACK;
5095 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5096 char *session = NULL;
5097 uint hex_charset = HEX_CHARSET;
5098 uint hex_salt = HEX_SALT;
5099 uint hex_wordlist = HEX_WORDLIST;
5100 uint rp_gen = RP_GEN;
5101 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5102 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5103 uint rp_gen_seed = RP_GEN_SEED;
5104 char *rule_buf_l = (char *) RULE_BUF_L;
5105 char *rule_buf_r = (char *) RULE_BUF_R;
5106 uint increment = INCREMENT;
5107 uint increment_min = INCREMENT_MIN;
5108 uint increment_max = INCREMENT_MAX;
5109 char *cpu_affinity = NULL;
5110 char *opencl_devices = NULL;
5111 char *opencl_platform = NULL;
5112 char *opencl_device_types = NULL;
5113 char *truecrypt_keyfiles = NULL;
5114 uint workload_profile = WORKLOAD_PROFILE;
5115 uint kernel_accel = KERNEL_ACCEL;
5116 uint kernel_loops = KERNEL_LOOPS;
5117 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5118 uint gpu_temp_abort = GPU_TEMP_ABORT;
5119 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5120 uint powertune_enable = POWERTUNE_ENABLE;
5121 uint logfile_disable = LOGFILE_DISABLE;
5122 uint segment_size = SEGMENT_SIZE;
5123 uint scrypt_tmto = SCRYPT_TMTO;
5124 char separator = SEPARATOR;
5125 uint bitmap_min = BITMAP_MIN;
5126 uint bitmap_max = BITMAP_MAX;
5127 char *custom_charset_1 = NULL;
5128 char *custom_charset_2 = NULL;
5129 char *custom_charset_3 = NULL;
5130 char *custom_charset_4 = NULL;
5131
5132 #define IDX_HELP 'h'
5133 #define IDX_VERSION 'V'
5134 #define IDX_VERSION_LOWER 'v'
5135 #define IDX_QUIET 0xff02
5136 #define IDX_SHOW 0xff03
5137 #define IDX_LEFT 0xff04
5138 #define IDX_REMOVE 0xff05
5139 #define IDX_REMOVE_TIMER 0xff37
5140 #define IDX_SKIP 's'
5141 #define IDX_LIMIT 'l'
5142 #define IDX_KEYSPACE 0xff35
5143 #define IDX_POTFILE_DISABLE 0xff06
5144 #define IDX_DEBUG_MODE 0xff43
5145 #define IDX_DEBUG_FILE 0xff44
5146 #define IDX_INDUCTION_DIR 0xff46
5147 #define IDX_OUTFILE_CHECK_DIR 0xff47
5148 #define IDX_USERNAME 0xff07
5149 #define IDX_FORCE 0xff08
5150 #define IDX_RUNTIME 0xff09
5151 #define IDX_BENCHMARK 'b'
5152 #define IDX_BENCHMARK_MODE 0xff32
5153 #define IDX_HASH_MODE 'm'
5154 #define IDX_ATTACK_MODE 'a'
5155 #define IDX_RP_FILE 'r'
5156 #define IDX_RP_GEN 'g'
5157 #define IDX_RP_GEN_FUNC_MIN 0xff10
5158 #define IDX_RP_GEN_FUNC_MAX 0xff11
5159 #define IDX_RP_GEN_SEED 0xff34
5160 #define IDX_RULE_BUF_L 'j'
5161 #define IDX_RULE_BUF_R 'k'
5162 #define IDX_INCREMENT 'i'
5163 #define IDX_INCREMENT_MIN 0xff12
5164 #define IDX_INCREMENT_MAX 0xff13
5165 #define IDX_OUTFILE 'o'
5166 #define IDX_OUTFILE_FORMAT 0xff14
5167 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5168 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5169 #define IDX_RESTORE 0xff15
5170 #define IDX_RESTORE_DISABLE 0xff27
5171 #define IDX_STATUS 0xff17
5172 #define IDX_STATUS_TIMER 0xff18
5173 #define IDX_STATUS_AUTOMAT 0xff50
5174 #define IDX_LOOPBACK 0xff38
5175 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5176 #define IDX_SESSION 0xff19
5177 #define IDX_HEX_CHARSET 0xff20
5178 #define IDX_HEX_SALT 0xff21
5179 #define IDX_HEX_WORDLIST 0xff40
5180 #define IDX_MARKOV_DISABLE 0xff22
5181 #define IDX_MARKOV_CLASSIC 0xff23
5182 #define IDX_MARKOV_THRESHOLD 't'
5183 #define IDX_MARKOV_HCSTAT 0xff24
5184 #define IDX_CPU_AFFINITY 0xff25
5185 #define IDX_OPENCL_DEVICES 'd'
5186 #define IDX_OPENCL_PLATFORM 0xff72
5187 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5188 #define IDX_WORKLOAD_PROFILE 'w'
5189 #define IDX_KERNEL_ACCEL 'n'
5190 #define IDX_KERNEL_LOOPS 'u'
5191 #define IDX_GPU_TEMP_DISABLE 0xff29
5192 #define IDX_GPU_TEMP_ABORT 0xff30
5193 #define IDX_GPU_TEMP_RETAIN 0xff31
5194 #define IDX_POWERTUNE_ENABLE 0xff41
5195 #define IDX_LOGFILE_DISABLE 0xff51
5196 #define IDX_TRUECRYPT_KEYFILES 0xff52
5197 #define IDX_SCRYPT_TMTO 0xff61
5198 #define IDX_SEGMENT_SIZE 'c'
5199 #define IDX_SEPARATOR 'p'
5200 #define IDX_BITMAP_MIN 0xff70
5201 #define IDX_BITMAP_MAX 0xff71
5202 #define IDX_CUSTOM_CHARSET_1 '1'
5203 #define IDX_CUSTOM_CHARSET_2 '2'
5204 #define IDX_CUSTOM_CHARSET_3 '3'
5205 #define IDX_CUSTOM_CHARSET_4 '4'
5206
5207 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5208
5209 struct option long_options[] =
5210 {
5211 {"help", no_argument, 0, IDX_HELP},
5212 {"version", no_argument, 0, IDX_VERSION},
5213 {"quiet", no_argument, 0, IDX_QUIET},
5214 {"show", no_argument, 0, IDX_SHOW},
5215 {"left", no_argument, 0, IDX_LEFT},
5216 {"username", no_argument, 0, IDX_USERNAME},
5217 {"remove", no_argument, 0, IDX_REMOVE},
5218 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5219 {"skip", required_argument, 0, IDX_SKIP},
5220 {"limit", required_argument, 0, IDX_LIMIT},
5221 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5222 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5223 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5224 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5225 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5226 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5227 {"force", no_argument, 0, IDX_FORCE},
5228 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5229 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5230 {"restore", no_argument, 0, IDX_RESTORE},
5231 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5232 {"status", no_argument, 0, IDX_STATUS},
5233 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5234 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5235 {"loopback", no_argument, 0, IDX_LOOPBACK},
5236 {"weak-hash-threshold",
5237 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5238 {"session", required_argument, 0, IDX_SESSION},
5239 {"runtime", required_argument, 0, IDX_RUNTIME},
5240 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5241 {"generate-rules-func-min",
5242 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5243 {"generate-rules-func-max",
5244 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5245 {"generate-rules-seed",
5246 required_argument, 0, IDX_RP_GEN_SEED},
5247 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5248 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5249 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5250 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5251 {"rules-file", required_argument, 0, IDX_RP_FILE},
5252 {"outfile", required_argument, 0, IDX_OUTFILE},
5253 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5254 {"outfile-autohex-disable",
5255 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5256 {"outfile-check-timer",
5257 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5258 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5259 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5260 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5261 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5262 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5263 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5264 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5265 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5266 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5267 {"opencl-platform", required_argument, 0, IDX_OPENCL_PLATFORM},
5268 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5269 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5270 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5271 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5272 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5273 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5274 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5275 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5276 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5277 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5278 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5279 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5280 // deprecated
5281 {"seperator", required_argument, 0, IDX_SEPARATOR},
5282 {"separator", required_argument, 0, IDX_SEPARATOR},
5283 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5284 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5285 {"increment", no_argument, 0, IDX_INCREMENT},
5286 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5287 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5288 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5289 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5290 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5291 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5292
5293 {0, 0, 0, 0}
5294 };
5295
5296 uint rp_files_cnt = 0;
5297
5298 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5299
5300 int option_index;
5301 int c;
5302
5303 optind = 1;
5304 optopt = 0;
5305 option_index = 0;
5306
5307 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5308 {
5309 switch (c)
5310 {
5311 case IDX_HELP: usage = 1; break;
5312 case IDX_VERSION:
5313 case IDX_VERSION_LOWER: version = 1; break;
5314 case IDX_RESTORE: restore = 1; break;
5315 case IDX_SESSION: session = optarg; break;
5316 case IDX_SHOW: show = 1; break;
5317 case IDX_LEFT: left = 1; break;
5318 case '?': return (-1);
5319 }
5320 }
5321
5322 if (optopt != 0)
5323 {
5324 log_error ("ERROR: Invalid argument specified");
5325
5326 return (-1);
5327 }
5328
5329 /**
5330 * exit functions
5331 */
5332
5333 if (version)
5334 {
5335 log_info (VERSION_TXT);
5336
5337 return (0);
5338 }
5339
5340 if (usage)
5341 {
5342 usage_big_print (PROGNAME);
5343
5344 return (0);
5345 }
5346
5347 /**
5348 * session needs to be set, always!
5349 */
5350
5351 if (session == NULL) session = (char *) PROGNAME;
5352
5353 /**
5354 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5355 */
5356
5357 char *exec_path = get_exec_path ();
5358
5359 #ifdef LINUX
5360
5361 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5362 char *resolved_exec_path = realpath (exec_path, NULL);
5363
5364 char *install_dir = get_install_dir (resolved_exec_path);
5365 char *profile_dir = NULL;
5366 char *session_dir = NULL;
5367 char *shared_dir = NULL;
5368
5369 if (strcmp (install_dir, resolved_install_folder) == 0)
5370 {
5371 struct passwd *pw = getpwuid (getuid ());
5372
5373 const char *homedir = pw->pw_dir;
5374
5375 profile_dir = get_profile_dir (homedir);
5376 session_dir = get_session_dir (profile_dir);
5377 shared_dir = strdup (SHARED_FOLDER);
5378
5379 mkdir (profile_dir, 0700);
5380 mkdir (session_dir, 0700);
5381 }
5382 else
5383 {
5384 profile_dir = install_dir;
5385 session_dir = install_dir;
5386 shared_dir = install_dir;
5387 }
5388
5389 myfree (resolved_install_folder);
5390 myfree (resolved_exec_path);
5391
5392 #else
5393
5394 char *install_dir = get_install_dir (exec_path);
5395 char *profile_dir = install_dir;
5396 char *session_dir = install_dir;
5397 char *shared_dir = install_dir;
5398
5399 #endif
5400
5401 data.install_dir = install_dir;
5402 data.profile_dir = profile_dir;
5403 data.session_dir = session_dir;
5404 data.shared_dir = shared_dir;
5405
5406 myfree (exec_path);
5407
5408 /**
5409 * session
5410 */
5411
5412 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5413
5414 data.session = session;
5415
5416 char *eff_restore_file = (char *) mymalloc (session_size);
5417 char *new_restore_file = (char *) mymalloc (session_size);
5418
5419 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5420 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5421
5422 data.eff_restore_file = eff_restore_file;
5423 data.new_restore_file = new_restore_file;
5424
5425 if (((show == 1) || (left == 1)) && (restore == 1))
5426 {
5427 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5428 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5429
5430 return (-1);
5431 }
5432
5433 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5434 if ((show == 1) || (left == 1))
5435 {
5436 restore_disable = 1;
5437
5438 restore = 0;
5439 }
5440
5441 data.restore_disable = restore_disable;
5442
5443 restore_data_t *rd = init_restore (argc, argv);
5444
5445 data.rd = rd;
5446
5447 /**
5448 * restore file
5449 */
5450
5451 if (restore == 1)
5452 {
5453 read_restore (eff_restore_file, rd);
5454
5455 if (rd->version_bin < RESTORE_MIN)
5456 {
5457 log_error ("ERROR: Incompatible restore-file version");
5458
5459 return (-1);
5460 }
5461
5462 myargc = rd->argc;
5463 myargv = rd->argv;
5464
5465 #ifdef _POSIX
5466 rd->pid = getpid ();
5467 #elif _WIN
5468 rd->pid = GetCurrentProcessId ();
5469 #endif
5470 }
5471
5472 uint hash_mode_chgd = 0;
5473 uint runtime_chgd = 0;
5474 uint kernel_loops_chgd = 0;
5475 uint kernel_accel_chgd = 0;
5476 uint attack_mode_chgd = 0;
5477 uint outfile_format_chgd = 0;
5478 uint rp_gen_seed_chgd = 0;
5479 uint remove_timer_chgd = 0;
5480 uint increment_min_chgd = 0;
5481 uint increment_max_chgd = 0;
5482 uint gpu_temp_abort_chgd = 0;
5483 uint gpu_temp_retain_chgd = 0;
5484
5485 optind = 1;
5486 optopt = 0;
5487 option_index = 0;
5488
5489 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5490 {
5491 switch (c)
5492 {
5493 //case IDX_HELP: usage = 1; break;
5494 //case IDX_VERSION: version = 1; break;
5495 //case IDX_RESTORE: restore = 1; break;
5496 case IDX_QUIET: quiet = 1; break;
5497 //case IDX_SHOW: show = 1; break;
5498 case IDX_SHOW: break;
5499 //case IDX_LEFT: left = 1; break;
5500 case IDX_LEFT: break;
5501 case IDX_USERNAME: username = 1; break;
5502 case IDX_REMOVE: remove = 1; break;
5503 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5504 remove_timer_chgd = 1; break;
5505 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5506 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5507 case IDX_DEBUG_FILE: debug_file = optarg; break;
5508 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5509 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5510 case IDX_FORCE: force = 1; break;
5511 case IDX_SKIP: skip = atoll (optarg); break;
5512 case IDX_LIMIT: limit = atoll (optarg); break;
5513 case IDX_KEYSPACE: keyspace = 1; break;
5514 case IDX_BENCHMARK: benchmark = 1; break;
5515 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5516 case IDX_RESTORE: break;
5517 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5518 case IDX_STATUS: status = 1; break;
5519 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5520 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5521 case IDX_LOOPBACK: loopback = 1; break;
5522 case IDX_WEAK_HASH_THRESHOLD:
5523 weak_hash_threshold = atoi (optarg); break;
5524 //case IDX_SESSION: session = optarg; break;
5525 case IDX_SESSION: break;
5526 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5527 hash_mode_chgd = 1; break;
5528 case IDX_RUNTIME: runtime = atoi (optarg);
5529 runtime_chgd = 1; break;
5530 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5531 attack_mode_chgd = 1; break;
5532 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5533 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5534 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5535 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5536 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5537 rp_gen_seed_chgd = 1; break;
5538 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5539 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5540 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5541 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5542 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5543 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5544 case IDX_OUTFILE: outfile = optarg; break;
5545 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5546 outfile_format_chgd = 1; break;
5547 case IDX_OUTFILE_AUTOHEX_DISABLE:
5548 outfile_autohex = 0; break;
5549 case IDX_OUTFILE_CHECK_TIMER:
5550 outfile_check_timer = atoi (optarg); break;
5551 case IDX_HEX_CHARSET: hex_charset = 1; break;
5552 case IDX_HEX_SALT: hex_salt = 1; break;
5553 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5554 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5555 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5556 case IDX_OPENCL_PLATFORM: opencl_platform = optarg; break;
5557 case IDX_OPENCL_DEVICE_TYPES:
5558 opencl_device_types = optarg; break;
5559 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5560 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5561 kernel_accel_chgd = 1; break;
5562 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5563 kernel_loops_chgd = 1; break;
5564 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5565 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5566 gpu_temp_abort = atoi (optarg); break;
5567 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5568 gpu_temp_retain = atoi (optarg); break;
5569 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5570 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5571 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5572 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5573 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5574 case IDX_SEPARATOR: separator = optarg[0]; break;
5575 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5576 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5577 case IDX_INCREMENT: increment = 1; break;
5578 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5579 increment_min_chgd = 1; break;
5580 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5581 increment_max_chgd = 1; break;
5582 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5583 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5584 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5585 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5586
5587 default:
5588 log_error ("ERROR: Invalid argument specified");
5589 return (-1);
5590 }
5591 }
5592
5593 if (optopt != 0)
5594 {
5595 log_error ("ERROR: Invalid argument specified");
5596
5597 return (-1);
5598 }
5599
5600 /**
5601 * Inform user things getting started,
5602 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5603 * - we do not need to check algorithm_pos
5604 */
5605
5606 if (quiet == 0)
5607 {
5608 if (benchmark == 1)
5609 {
5610 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5611
5612 log_info ("");
5613 }
5614 else if (restore == 1)
5615 {
5616 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5617
5618 log_info ("");
5619 }
5620 else
5621 {
5622 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5623
5624 log_info ("");
5625 }
5626 }
5627
5628 /**
5629 * sanity check
5630 */
5631
5632 if (attack_mode > 7)
5633 {
5634 log_error ("ERROR: Invalid attack-mode specified");
5635
5636 return (-1);
5637 }
5638
5639 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5640 {
5641 log_error ("ERROR: Invalid runtime specified");
5642
5643 return (-1);
5644 }
5645
5646 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5647 {
5648 log_error ("ERROR: Invalid hash-type specified");
5649
5650 return (-1);
5651 }
5652
5653 // renamed hash modes
5654
5655 if (hash_mode_chgd)
5656 {
5657 int n = -1;
5658
5659 switch (hash_mode)
5660 {
5661 case 123: n = 124;
5662 break;
5663 }
5664
5665 if (n >= 0)
5666 {
5667 log_error ("Old -m specified, use -m %d instead", n);
5668
5669 return (-1);
5670 }
5671 }
5672
5673 if (username == 1)
5674 {
5675 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5676 {
5677 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5678
5679 return (-1);
5680 }
5681 }
5682
5683 if (outfile_format > 16)
5684 {
5685 log_error ("ERROR: Invalid outfile-format specified");
5686
5687 return (-1);
5688 }
5689
5690 if (left == 1)
5691 {
5692 if (outfile_format_chgd == 1)
5693 {
5694 if (outfile_format > 1)
5695 {
5696 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5697
5698 return (-1);
5699 }
5700 }
5701 else
5702 {
5703 outfile_format = OUTFILE_FMT_HASH;
5704 }
5705 }
5706
5707 if (show == 1)
5708 {
5709 if (outfile_format_chgd == 1)
5710 {
5711 if ((outfile_format > 7) && (outfile_format < 16))
5712 {
5713 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5714
5715 return (-1);
5716 }
5717 }
5718 }
5719
5720 if (increment_min < INCREMENT_MIN)
5721 {
5722 log_error ("ERROR: Invalid increment-min specified");
5723
5724 return (-1);
5725 }
5726
5727 if (increment_max > INCREMENT_MAX)
5728 {
5729 log_error ("ERROR: Invalid increment-max specified");
5730
5731 return (-1);
5732 }
5733
5734 if (increment_min > increment_max)
5735 {
5736 log_error ("ERROR: Invalid increment-min specified");
5737
5738 return (-1);
5739 }
5740
5741 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5742 {
5743 log_error ("ERROR: increment is not allowed in attack-mode 0");
5744
5745 return (-1);
5746 }
5747
5748 if ((increment == 0) && (increment_min_chgd == 1))
5749 {
5750 log_error ("ERROR: increment-min is only supported together with increment switch");
5751
5752 return (-1);
5753 }
5754
5755 if ((increment == 0) && (increment_max_chgd == 1))
5756 {
5757 log_error ("ERROR: increment-max is only supported together with increment switch");
5758
5759 return (-1);
5760 }
5761
5762 if (rp_files_cnt && rp_gen)
5763 {
5764 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5765
5766 return (-1);
5767 }
5768
5769 if (rp_files_cnt || rp_gen)
5770 {
5771 if (attack_mode != ATTACK_MODE_STRAIGHT)
5772 {
5773 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5774
5775 return (-1);
5776 }
5777 }
5778
5779 if (rp_gen_func_min > rp_gen_func_max)
5780 {
5781 log_error ("ERROR: Invalid rp-gen-func-min specified");
5782
5783 return (-1);
5784 }
5785
5786 if (kernel_accel_chgd == 1)
5787 {
5788 if (workload_profile != WORKLOAD_PROFILE)
5789 {
5790 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5791
5792 return (-1);
5793 }
5794
5795 if (kernel_accel < 1)
5796 {
5797 log_error ("ERROR: Invalid kernel-accel specified");
5798
5799 return (-1);
5800 }
5801
5802 if (kernel_accel > 800)
5803 {
5804 log_error ("ERROR: Invalid kernel-accel specified");
5805
5806 return (-1);
5807 }
5808 }
5809
5810 if (kernel_loops_chgd == 1)
5811 {
5812 if (workload_profile != WORKLOAD_PROFILE)
5813 {
5814 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5815
5816 return (-1);
5817 }
5818
5819 if (kernel_loops < 1)
5820 {
5821 log_error ("ERROR: Invalid kernel-loops specified");
5822
5823 return (-1);
5824 }
5825
5826 if (kernel_loops > 1024)
5827 {
5828 log_error ("ERROR: Invalid kernel-loops specified");
5829
5830 return (-1);
5831 }
5832 }
5833
5834 if (benchmark == 1)
5835 {
5836 if (workload_profile != WORKLOAD_PROFILE)
5837 {
5838 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5839
5840 return (-1);
5841 }
5842 }
5843
5844 if ((workload_profile < 1) || (workload_profile > 3))
5845 {
5846 log_error ("ERROR: workload-profile %i not available", workload_profile);
5847
5848 return (-1);
5849 }
5850
5851 if (show == 1 || left == 1)
5852 {
5853 attack_mode = ATTACK_MODE_NONE;
5854
5855 if (remove == 1)
5856 {
5857 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5858
5859 return (-1);
5860 }
5861
5862 if (potfile_disable == 1)
5863 {
5864 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5865
5866 return (-1);
5867 }
5868 }
5869
5870 uint attack_kern = ATTACK_KERN_NONE;
5871
5872 switch (attack_mode)
5873 {
5874 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5875 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5876 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5877 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5878 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5879 }
5880
5881 if (benchmark == 0)
5882 {
5883 if (keyspace == 1)
5884 {
5885 int num_additional_params = 1;
5886
5887 if (attack_kern == ATTACK_KERN_COMBI)
5888 {
5889 num_additional_params = 2;
5890 }
5891
5892 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5893
5894 if (keyspace_wordlist_specified == 0) optind--;
5895 }
5896
5897 if (attack_kern == ATTACK_KERN_NONE)
5898 {
5899 if ((optind + 1) != myargc)
5900 {
5901 usage_mini_print (myargv[0]);
5902
5903 return (-1);
5904 }
5905 }
5906 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5907 {
5908 if ((optind + 1) > myargc)
5909 {
5910 usage_mini_print (myargv[0]);
5911
5912 return (-1);
5913 }
5914 }
5915 else if (attack_kern == ATTACK_KERN_COMBI)
5916 {
5917 if ((optind + 3) != myargc)
5918 {
5919 usage_mini_print (myargv[0]);
5920
5921 return (-1);
5922 }
5923 }
5924 else if (attack_kern == ATTACK_KERN_BF)
5925 {
5926 if ((optind + 1) > myargc)
5927 {
5928 usage_mini_print (myargv[0]);
5929
5930 return (-1);
5931 }
5932 }
5933 else
5934 {
5935 usage_mini_print (myargv[0]);
5936
5937 return (-1);
5938 }
5939 }
5940 else
5941 {
5942 if (myargv[optind] != 0)
5943 {
5944 log_error ("ERROR: Invalid argument for benchmark mode specified");
5945
5946 return (-1);
5947 }
5948
5949 if (attack_mode_chgd == 1)
5950 {
5951 if (attack_mode != ATTACK_MODE_BF)
5952 {
5953 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5954
5955 return (-1);
5956 }
5957 }
5958
5959 if (benchmark_mode == 0)
5960 {
5961 // nothing to do
5962 }
5963 else if (benchmark_mode == 1)
5964 {
5965 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
5966 {
5967 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
5968
5969 return (-1);
5970 }
5971 }
5972 else
5973 {
5974 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5975
5976 return (-1);
5977 }
5978 }
5979
5980 if (skip != 0 && limit != 0)
5981 {
5982 limit += skip;
5983 }
5984
5985 if (keyspace == 1)
5986 {
5987 if (show == 1)
5988 {
5989 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
5990
5991 return (-1);
5992 }
5993 else if (left == 1)
5994 {
5995 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
5996
5997 return (-1);
5998 }
5999
6000 potfile_disable = 1;
6001
6002 restore_disable = 1;
6003
6004 restore = 0;
6005
6006 weak_hash_threshold = 0;
6007
6008 quiet = 1;
6009 }
6010
6011 if (remove_timer_chgd == 1)
6012 {
6013 if (remove == 0)
6014 {
6015 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6016
6017 return (-1);
6018 }
6019
6020 if (remove_timer < 1)
6021 {
6022 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6023
6024 return (-1);
6025 }
6026 }
6027
6028 if (loopback == 1)
6029 {
6030 if (attack_mode == ATTACK_MODE_BF)
6031 {
6032 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6033
6034 return (-1);
6035 }
6036 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6037 {
6038 if ((rp_files_cnt == 0) && (rp_gen == 0))
6039 {
6040 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6041
6042 return (-1);
6043 }
6044 }
6045 }
6046
6047 if (debug_mode > 0)
6048 {
6049 if (attack_mode != ATTACK_MODE_STRAIGHT)
6050 {
6051 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6052
6053 return (-1);
6054 }
6055
6056 if ((rp_files_cnt == 0) && (rp_gen == 0))
6057 {
6058 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6059
6060 return (-1);
6061 }
6062 }
6063
6064 if (debug_mode > 4)
6065 {
6066 log_error ("ERROR: Invalid debug-mode specified");
6067
6068 return (-1);
6069 }
6070
6071 if (debug_file != NULL)
6072 {
6073 if (debug_mode < 1)
6074 {
6075 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6076
6077 return (-1);
6078 }
6079 }
6080
6081 if (induction_dir != NULL)
6082 {
6083 if (attack_mode == ATTACK_MODE_BF)
6084 {
6085 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6086
6087 return (-1);
6088 }
6089 }
6090
6091 /**
6092 * induction directory
6093 */
6094
6095 char *induction_directory = NULL;
6096
6097 if (attack_mode != ATTACK_MODE_BF)
6098 {
6099 if (induction_dir == NULL)
6100 {
6101 induction_directory = (char *) mymalloc (session_size);
6102
6103 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6104
6105 // create induction folder if it does not already exist
6106
6107 if (keyspace == 0)
6108 {
6109 if (rmdir (induction_directory) == -1)
6110 {
6111 if (errno == ENOENT)
6112 {
6113 // good, we can ignore
6114 }
6115 else if (errno == ENOTEMPTY)
6116 {
6117 char *induction_directory_mv = (char *) mymalloc (session_size);
6118
6119 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6120
6121 if (rename (induction_directory, induction_directory_mv) != 0)
6122 {
6123 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6124
6125 return (-1);
6126 }
6127 }
6128 else
6129 {
6130 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6131
6132 return (-1);
6133 }
6134 }
6135
6136 if (mkdir (induction_directory, 0700) == -1)
6137 {
6138 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6139
6140 return (-1);
6141 }
6142 }
6143 }
6144 else
6145 {
6146 induction_directory = induction_dir;
6147 }
6148 }
6149
6150 data.induction_directory = induction_directory;
6151
6152 /**
6153 * loopback
6154 */
6155
6156 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6157
6158 char *loopback_file = (char *) mymalloc (loopback_size);
6159
6160 /**
6161 * outfile-check directory
6162 */
6163
6164 char *outfile_check_directory = NULL;
6165
6166 if (outfile_check_dir == NULL)
6167 {
6168 outfile_check_directory = (char *) mymalloc (session_size);
6169
6170 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6171 }
6172 else
6173 {
6174 outfile_check_directory = outfile_check_dir;
6175 }
6176
6177 data.outfile_check_directory = outfile_check_directory;
6178
6179 if (keyspace == 0)
6180 {
6181 struct stat outfile_check_stat;
6182
6183 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6184 {
6185 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6186
6187 if (is_dir == 0)
6188 {
6189 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6190
6191 return (-1);
6192 }
6193 }
6194 else if (outfile_check_dir == NULL)
6195 {
6196 if (mkdir (outfile_check_directory, 0700) == -1)
6197 {
6198 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6199
6200 return (-1);
6201 }
6202 }
6203 }
6204
6205 /**
6206 * special other stuff
6207 */
6208
6209 if (hash_mode == 9710)
6210 {
6211 outfile_format = 5;
6212 outfile_format_chgd = 1;
6213 }
6214
6215 if (hash_mode == 9810)
6216 {
6217 outfile_format = 5;
6218 outfile_format_chgd = 1;
6219 }
6220
6221 if (hash_mode == 10410)
6222 {
6223 outfile_format = 5;
6224 outfile_format_chgd = 1;
6225 }
6226
6227 /**
6228 * store stuff
6229 */
6230
6231 data.hash_mode = hash_mode;
6232 data.restore = restore;
6233 data.restore_timer = restore_timer;
6234 data.restore_disable = restore_disable;
6235 data.status = status;
6236 data.status_timer = status_timer;
6237 data.status_automat = status_automat;
6238 data.loopback = loopback;
6239 data.runtime = runtime;
6240 data.remove = remove;
6241 data.remove_timer = remove_timer;
6242 data.debug_mode = debug_mode;
6243 data.debug_file = debug_file;
6244 data.username = username;
6245 data.quiet = quiet;
6246 data.outfile = outfile;
6247 data.outfile_format = outfile_format;
6248 data.outfile_autohex = outfile_autohex;
6249 data.hex_charset = hex_charset;
6250 data.hex_salt = hex_salt;
6251 data.hex_wordlist = hex_wordlist;
6252 data.separator = separator;
6253 data.rp_files = rp_files;
6254 data.rp_files_cnt = rp_files_cnt;
6255 data.rp_gen = rp_gen;
6256 data.rp_gen_seed = rp_gen_seed;
6257 data.force = force;
6258 data.benchmark = benchmark;
6259 data.skip = skip;
6260 data.limit = limit;
6261 data.powertune_enable = powertune_enable;
6262 data.logfile_disable = logfile_disable;
6263 data.truecrypt_keyfiles = truecrypt_keyfiles;
6264 data.scrypt_tmto = scrypt_tmto;
6265
6266 /**
6267 * cpu affinity
6268 */
6269
6270 if (cpu_affinity)
6271 {
6272 set_cpu_affinity (cpu_affinity);
6273 }
6274
6275 if (rp_gen_seed_chgd == 0)
6276 {
6277 srand (proc_start);
6278 }
6279 else
6280 {
6281 srand (rp_gen_seed);
6282 }
6283
6284 /**
6285 * logfile init
6286 */
6287
6288 if (logfile_disable == 0)
6289 {
6290 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6291
6292 char *logfile = (char *) mymalloc (logfile_size);
6293
6294 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6295
6296 data.logfile = logfile;
6297
6298 char *topid = logfile_generate_topid ();
6299
6300 data.topid = topid;
6301 }
6302
6303 // logfile_append() checks for logfile_disable internally to make it easier from here
6304
6305 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6306 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6307 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6308 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6309 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6310 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6311 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6312 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6313 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6314 #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));
6315
6316 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6317 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6318 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6319 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6320 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6321 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6322 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6323 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6324
6325 logfile_top_msg ("START");
6326
6327 logfile_top_uint (attack_mode);
6328 logfile_top_uint (attack_kern);
6329 logfile_top_uint (benchmark);
6330 logfile_top_uint (benchmark_mode);
6331 logfile_top_uint (bitmap_min);
6332 logfile_top_uint (bitmap_max);
6333 logfile_top_uint (debug_mode);
6334 logfile_top_uint (force);
6335 logfile_top_uint (kernel_accel);
6336 logfile_top_uint (kernel_loops);
6337 logfile_top_uint (gpu_temp_abort);
6338 logfile_top_uint (gpu_temp_disable);
6339 logfile_top_uint (gpu_temp_retain);
6340 logfile_top_uint (hash_mode);
6341 logfile_top_uint (hex_charset);
6342 logfile_top_uint (hex_salt);
6343 logfile_top_uint (hex_wordlist);
6344 logfile_top_uint (increment);
6345 logfile_top_uint (increment_max);
6346 logfile_top_uint (increment_min);
6347 logfile_top_uint (keyspace);
6348 logfile_top_uint (left);
6349 logfile_top_uint (logfile_disable);
6350 logfile_top_uint (loopback);
6351 logfile_top_uint (markov_classic);
6352 logfile_top_uint (markov_disable);
6353 logfile_top_uint (markov_threshold);
6354 logfile_top_uint (outfile_autohex);
6355 logfile_top_uint (outfile_check_timer);
6356 logfile_top_uint (outfile_format);
6357 logfile_top_uint (potfile_disable);
6358 logfile_top_uint (powertune_enable);
6359 logfile_top_uint (scrypt_tmto);
6360 logfile_top_uint (quiet);
6361 logfile_top_uint (remove);
6362 logfile_top_uint (remove_timer);
6363 logfile_top_uint (restore);
6364 logfile_top_uint (restore_disable);
6365 logfile_top_uint (restore_timer);
6366 logfile_top_uint (rp_gen);
6367 logfile_top_uint (rp_gen_func_max);
6368 logfile_top_uint (rp_gen_func_min);
6369 logfile_top_uint (rp_gen_seed);
6370 logfile_top_uint (runtime);
6371 logfile_top_uint (segment_size);
6372 logfile_top_uint (show);
6373 logfile_top_uint (status);
6374 logfile_top_uint (status_automat);
6375 logfile_top_uint (status_timer);
6376 logfile_top_uint (usage);
6377 logfile_top_uint (username);
6378 logfile_top_uint (version);
6379 logfile_top_uint (weak_hash_threshold);
6380 logfile_top_uint (workload_profile);
6381 logfile_top_uint64 (limit);
6382 logfile_top_uint64 (skip);
6383 logfile_top_char (separator);
6384 logfile_top_string (cpu_affinity);
6385 logfile_top_string (custom_charset_1);
6386 logfile_top_string (custom_charset_2);
6387 logfile_top_string (custom_charset_3);
6388 logfile_top_string (custom_charset_4);
6389 logfile_top_string (debug_file);
6390 logfile_top_string (opencl_devices);
6391 logfile_top_string (opencl_platform);
6392 logfile_top_string (opencl_device_types);
6393 logfile_top_string (induction_dir);
6394 logfile_top_string (markov_hcstat);
6395 logfile_top_string (outfile);
6396 logfile_top_string (outfile_check_dir);
6397 logfile_top_string (rule_buf_l);
6398 logfile_top_string (rule_buf_r);
6399 logfile_top_string (session);
6400 logfile_top_string (truecrypt_keyfiles);
6401
6402 /**
6403 * device types filter
6404 */
6405
6406 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6407
6408 /**
6409 * devices
6410 */
6411
6412 uint opencl_devicemask = devices_to_devicemask (opencl_devices);
6413
6414 /**
6415 * benchmark
6416 */
6417
6418 if (benchmark == 1)
6419 {
6420 /**
6421 * disable useless stuff for benchmark
6422 */
6423
6424 restore_timer = 0;
6425 status_timer = 0;
6426 restore_disable = 1;
6427 potfile_disable = 1;
6428 weak_hash_threshold = 0;
6429
6430 data.restore_timer = restore_timer;
6431 data.status_timer = status_timer;
6432 data.restore_disable = restore_disable;
6433
6434 if (benchmark_mode == 1)
6435 {
6436 markov_disable = 1;
6437 }
6438
6439 /**
6440 * force attack mode to be bruteforce
6441 */
6442
6443 attack_mode = ATTACK_MODE_BF;
6444 attack_kern = ATTACK_KERN_BF;
6445
6446 if (runtime_chgd == 0)
6447 {
6448 runtime = 4;
6449
6450 if (benchmark_mode == 1) runtime = 17;
6451
6452 data.runtime = runtime;
6453 }
6454 }
6455
6456 /**
6457 * config
6458 */
6459
6460 uint hash_type = 0;
6461 uint salt_type = 0;
6462 uint attack_exec = 0;
6463 uint opts_type = 0;
6464 uint kern_type = 0;
6465 uint dgst_size = 0;
6466 uint esalt_size = 0;
6467 uint opti_type = 0;
6468 uint dgst_pos0 = -1;
6469 uint dgst_pos1 = -1;
6470 uint dgst_pos2 = -1;
6471 uint dgst_pos3 = -1;
6472
6473 int (*parse_func) (char *, uint, hash_t *);
6474 int (*sort_by_digest) (const void *, const void *);
6475
6476 uint algorithm_pos = 0;
6477 uint algorithm_max = 1;
6478
6479 uint *algorithms = default_benchmark_algorithms;
6480
6481 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6482
6483 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6484 {
6485 /*
6486 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6487 * the following algos are skipped entirely
6488 */
6489
6490 if (algorithm_pos > 0)
6491 {
6492 local_free (rd);
6493
6494 rd = init_restore (argc, argv);
6495
6496 data.rd = rd;
6497 }
6498
6499 /**
6500 * update hash_mode in case of multihash benchmark
6501 */
6502
6503 if (benchmark == 1)
6504 {
6505 if (hash_mode_chgd == 0)
6506 {
6507 hash_mode = algorithms[algorithm_pos];
6508
6509 data.hash_mode = hash_mode;
6510 }
6511
6512 quiet = 1;
6513
6514 data.quiet = quiet;
6515 }
6516
6517 switch (hash_mode)
6518 {
6519 case 0: hash_type = HASH_TYPE_MD5;
6520 salt_type = SALT_TYPE_NONE;
6521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6522 opts_type = OPTS_TYPE_PT_GENERATE_LE
6523 | OPTS_TYPE_PT_ADD80
6524 | OPTS_TYPE_PT_ADDBITS14;
6525 kern_type = KERN_TYPE_MD5;
6526 dgst_size = DGST_SIZE_4_4;
6527 parse_func = md5_parse_hash;
6528 sort_by_digest = sort_by_digest_4_4;
6529 opti_type = OPTI_TYPE_ZERO_BYTE
6530 | OPTI_TYPE_PRECOMPUTE_INIT
6531 | OPTI_TYPE_PRECOMPUTE_MERKLE
6532 | OPTI_TYPE_MEET_IN_MIDDLE
6533 | OPTI_TYPE_EARLY_SKIP
6534 | OPTI_TYPE_NOT_ITERATED
6535 | OPTI_TYPE_NOT_SALTED
6536 | OPTI_TYPE_RAW_HASH;
6537 dgst_pos0 = 0;
6538 dgst_pos1 = 3;
6539 dgst_pos2 = 2;
6540 dgst_pos3 = 1;
6541 break;
6542
6543 case 10: hash_type = HASH_TYPE_MD5;
6544 salt_type = SALT_TYPE_INTERN;
6545 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6546 opts_type = OPTS_TYPE_PT_GENERATE_LE
6547 | OPTS_TYPE_ST_ADD80
6548 | OPTS_TYPE_ST_ADDBITS14;
6549 kern_type = KERN_TYPE_MD5_PWSLT;
6550 dgst_size = DGST_SIZE_4_4;
6551 parse_func = md5s_parse_hash;
6552 sort_by_digest = sort_by_digest_4_4;
6553 opti_type = OPTI_TYPE_ZERO_BYTE
6554 | OPTI_TYPE_PRECOMPUTE_INIT
6555 | OPTI_TYPE_PRECOMPUTE_MERKLE
6556 | OPTI_TYPE_MEET_IN_MIDDLE
6557 | OPTI_TYPE_EARLY_SKIP
6558 | OPTI_TYPE_NOT_ITERATED
6559 | OPTI_TYPE_APPENDED_SALT
6560 | OPTI_TYPE_RAW_HASH;
6561 dgst_pos0 = 0;
6562 dgst_pos1 = 3;
6563 dgst_pos2 = 2;
6564 dgst_pos3 = 1;
6565 break;
6566
6567 case 11: hash_type = HASH_TYPE_MD5;
6568 salt_type = SALT_TYPE_INTERN;
6569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6570 opts_type = OPTS_TYPE_PT_GENERATE_LE
6571 | OPTS_TYPE_ST_ADD80
6572 | OPTS_TYPE_ST_ADDBITS14;
6573 kern_type = KERN_TYPE_MD5_PWSLT;
6574 dgst_size = DGST_SIZE_4_4;
6575 parse_func = joomla_parse_hash;
6576 sort_by_digest = sort_by_digest_4_4;
6577 opti_type = OPTI_TYPE_ZERO_BYTE
6578 | OPTI_TYPE_PRECOMPUTE_INIT
6579 | OPTI_TYPE_PRECOMPUTE_MERKLE
6580 | OPTI_TYPE_MEET_IN_MIDDLE
6581 | OPTI_TYPE_EARLY_SKIP
6582 | OPTI_TYPE_NOT_ITERATED
6583 | OPTI_TYPE_APPENDED_SALT
6584 | OPTI_TYPE_RAW_HASH;
6585 dgst_pos0 = 0;
6586 dgst_pos1 = 3;
6587 dgst_pos2 = 2;
6588 dgst_pos3 = 1;
6589 break;
6590
6591 case 12: hash_type = HASH_TYPE_MD5;
6592 salt_type = SALT_TYPE_INTERN;
6593 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6594 opts_type = OPTS_TYPE_PT_GENERATE_LE
6595 | OPTS_TYPE_ST_ADD80
6596 | OPTS_TYPE_ST_ADDBITS14;
6597 kern_type = KERN_TYPE_MD5_PWSLT;
6598 dgst_size = DGST_SIZE_4_4;
6599 parse_func = postgresql_parse_hash;
6600 sort_by_digest = sort_by_digest_4_4;
6601 opti_type = OPTI_TYPE_ZERO_BYTE
6602 | OPTI_TYPE_PRECOMPUTE_INIT
6603 | OPTI_TYPE_PRECOMPUTE_MERKLE
6604 | OPTI_TYPE_MEET_IN_MIDDLE
6605 | OPTI_TYPE_EARLY_SKIP
6606 | OPTI_TYPE_NOT_ITERATED
6607 | OPTI_TYPE_APPENDED_SALT
6608 | OPTI_TYPE_RAW_HASH;
6609 dgst_pos0 = 0;
6610 dgst_pos1 = 3;
6611 dgst_pos2 = 2;
6612 dgst_pos3 = 1;
6613 break;
6614
6615 case 20: hash_type = HASH_TYPE_MD5;
6616 salt_type = SALT_TYPE_INTERN;
6617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6618 opts_type = OPTS_TYPE_PT_GENERATE_LE
6619 | OPTS_TYPE_PT_ADD80
6620 | OPTS_TYPE_PT_ADDBITS14;
6621 kern_type = KERN_TYPE_MD5_SLTPW;
6622 dgst_size = DGST_SIZE_4_4;
6623 parse_func = md5s_parse_hash;
6624 sort_by_digest = sort_by_digest_4_4;
6625 opti_type = OPTI_TYPE_ZERO_BYTE
6626 | OPTI_TYPE_PRECOMPUTE_INIT
6627 | OPTI_TYPE_PRECOMPUTE_MERKLE
6628 | OPTI_TYPE_EARLY_SKIP
6629 | OPTI_TYPE_NOT_ITERATED
6630 | OPTI_TYPE_PREPENDED_SALT
6631 | OPTI_TYPE_RAW_HASH;
6632 dgst_pos0 = 0;
6633 dgst_pos1 = 3;
6634 dgst_pos2 = 2;
6635 dgst_pos3 = 1;
6636 break;
6637
6638 case 21: hash_type = HASH_TYPE_MD5;
6639 salt_type = SALT_TYPE_INTERN;
6640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6641 opts_type = OPTS_TYPE_PT_GENERATE_LE
6642 | OPTS_TYPE_PT_ADD80
6643 | OPTS_TYPE_PT_ADDBITS14;
6644 kern_type = KERN_TYPE_MD5_SLTPW;
6645 dgst_size = DGST_SIZE_4_4;
6646 parse_func = osc_parse_hash;
6647 sort_by_digest = sort_by_digest_4_4;
6648 opti_type = OPTI_TYPE_ZERO_BYTE
6649 | OPTI_TYPE_PRECOMPUTE_INIT
6650 | OPTI_TYPE_PRECOMPUTE_MERKLE
6651 | OPTI_TYPE_EARLY_SKIP
6652 | OPTI_TYPE_NOT_ITERATED
6653 | OPTI_TYPE_PREPENDED_SALT
6654 | OPTI_TYPE_RAW_HASH;
6655 dgst_pos0 = 0;
6656 dgst_pos1 = 3;
6657 dgst_pos2 = 2;
6658 dgst_pos3 = 1;
6659 break;
6660
6661 case 22: hash_type = HASH_TYPE_MD5;
6662 salt_type = SALT_TYPE_EMBEDDED;
6663 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6664 opts_type = OPTS_TYPE_PT_GENERATE_LE
6665 | OPTS_TYPE_PT_ADD80
6666 | OPTS_TYPE_PT_ADDBITS14;
6667 kern_type = KERN_TYPE_MD5_SLTPW;
6668 dgst_size = DGST_SIZE_4_4;
6669 parse_func = netscreen_parse_hash;
6670 sort_by_digest = sort_by_digest_4_4;
6671 opti_type = OPTI_TYPE_ZERO_BYTE
6672 | OPTI_TYPE_PRECOMPUTE_INIT
6673 | OPTI_TYPE_PRECOMPUTE_MERKLE
6674 | OPTI_TYPE_EARLY_SKIP
6675 | OPTI_TYPE_NOT_ITERATED
6676 | OPTI_TYPE_PREPENDED_SALT
6677 | OPTI_TYPE_RAW_HASH;
6678 dgst_pos0 = 0;
6679 dgst_pos1 = 3;
6680 dgst_pos2 = 2;
6681 dgst_pos3 = 1;
6682 break;
6683
6684 case 23: hash_type = HASH_TYPE_MD5;
6685 salt_type = SALT_TYPE_EMBEDDED;
6686 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6687 opts_type = OPTS_TYPE_PT_GENERATE_LE
6688 | OPTS_TYPE_PT_ADD80
6689 | OPTS_TYPE_PT_ADDBITS14;
6690 kern_type = KERN_TYPE_MD5_SLTPW;
6691 dgst_size = DGST_SIZE_4_4;
6692 parse_func = skype_parse_hash;
6693 sort_by_digest = sort_by_digest_4_4;
6694 opti_type = OPTI_TYPE_ZERO_BYTE
6695 | OPTI_TYPE_PRECOMPUTE_INIT
6696 | OPTI_TYPE_PRECOMPUTE_MERKLE
6697 | OPTI_TYPE_EARLY_SKIP
6698 | OPTI_TYPE_NOT_ITERATED
6699 | OPTI_TYPE_PREPENDED_SALT
6700 | OPTI_TYPE_RAW_HASH;
6701 dgst_pos0 = 0;
6702 dgst_pos1 = 3;
6703 dgst_pos2 = 2;
6704 dgst_pos3 = 1;
6705 break;
6706
6707 case 30: hash_type = HASH_TYPE_MD5;
6708 salt_type = SALT_TYPE_INTERN;
6709 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6710 opts_type = OPTS_TYPE_PT_GENERATE_LE
6711 | OPTS_TYPE_PT_UNICODE
6712 | OPTS_TYPE_ST_ADD80
6713 | OPTS_TYPE_ST_ADDBITS14;
6714 kern_type = KERN_TYPE_MD5_PWUSLT;
6715 dgst_size = DGST_SIZE_4_4;
6716 parse_func = md5s_parse_hash;
6717 sort_by_digest = sort_by_digest_4_4;
6718 opti_type = OPTI_TYPE_ZERO_BYTE
6719 | OPTI_TYPE_PRECOMPUTE_INIT
6720 | OPTI_TYPE_PRECOMPUTE_MERKLE
6721 | OPTI_TYPE_MEET_IN_MIDDLE
6722 | OPTI_TYPE_EARLY_SKIP
6723 | OPTI_TYPE_NOT_ITERATED
6724 | OPTI_TYPE_APPENDED_SALT
6725 | OPTI_TYPE_RAW_HASH;
6726 dgst_pos0 = 0;
6727 dgst_pos1 = 3;
6728 dgst_pos2 = 2;
6729 dgst_pos3 = 1;
6730 break;
6731
6732 case 40: hash_type = HASH_TYPE_MD5;
6733 salt_type = SALT_TYPE_INTERN;
6734 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6735 opts_type = OPTS_TYPE_PT_GENERATE_LE
6736 | OPTS_TYPE_PT_ADD80
6737 | OPTS_TYPE_PT_ADDBITS14
6738 | OPTS_TYPE_PT_UNICODE;
6739 kern_type = KERN_TYPE_MD5_SLTPWU;
6740 dgst_size = DGST_SIZE_4_4;
6741 parse_func = md5s_parse_hash;
6742 sort_by_digest = sort_by_digest_4_4;
6743 opti_type = OPTI_TYPE_ZERO_BYTE
6744 | OPTI_TYPE_PRECOMPUTE_INIT
6745 | OPTI_TYPE_PRECOMPUTE_MERKLE
6746 | OPTI_TYPE_EARLY_SKIP
6747 | OPTI_TYPE_NOT_ITERATED
6748 | OPTI_TYPE_PREPENDED_SALT
6749 | OPTI_TYPE_RAW_HASH;
6750 dgst_pos0 = 0;
6751 dgst_pos1 = 3;
6752 dgst_pos2 = 2;
6753 dgst_pos3 = 1;
6754 break;
6755
6756 case 50: hash_type = HASH_TYPE_MD5;
6757 salt_type = SALT_TYPE_INTERN;
6758 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6759 opts_type = OPTS_TYPE_PT_GENERATE_LE
6760 | OPTS_TYPE_ST_ADD80
6761 | OPTS_TYPE_ST_ADDBITS14;
6762 kern_type = KERN_TYPE_HMACMD5_PW;
6763 dgst_size = DGST_SIZE_4_4;
6764 parse_func = hmacmd5_parse_hash;
6765 sort_by_digest = sort_by_digest_4_4;
6766 opti_type = OPTI_TYPE_ZERO_BYTE
6767 | OPTI_TYPE_NOT_ITERATED;
6768 dgst_pos0 = 0;
6769 dgst_pos1 = 3;
6770 dgst_pos2 = 2;
6771 dgst_pos3 = 1;
6772 break;
6773
6774 case 60: hash_type = HASH_TYPE_MD5;
6775 salt_type = SALT_TYPE_INTERN;
6776 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6777 opts_type = OPTS_TYPE_PT_GENERATE_LE
6778 | OPTS_TYPE_PT_ADD80
6779 | OPTS_TYPE_PT_ADDBITS14;
6780 kern_type = KERN_TYPE_HMACMD5_SLT;
6781 dgst_size = DGST_SIZE_4_4;
6782 parse_func = hmacmd5_parse_hash;
6783 sort_by_digest = sort_by_digest_4_4;
6784 opti_type = OPTI_TYPE_ZERO_BYTE
6785 | OPTI_TYPE_NOT_ITERATED;
6786 dgst_pos0 = 0;
6787 dgst_pos1 = 3;
6788 dgst_pos2 = 2;
6789 dgst_pos3 = 1;
6790 break;
6791
6792 case 100: hash_type = HASH_TYPE_SHA1;
6793 salt_type = SALT_TYPE_NONE;
6794 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6795 opts_type = OPTS_TYPE_PT_GENERATE_BE
6796 | OPTS_TYPE_PT_ADD80
6797 | OPTS_TYPE_PT_ADDBITS15;
6798 kern_type = KERN_TYPE_SHA1;
6799 dgst_size = DGST_SIZE_4_5;
6800 parse_func = sha1_parse_hash;
6801 sort_by_digest = sort_by_digest_4_5;
6802 opti_type = OPTI_TYPE_ZERO_BYTE
6803 | OPTI_TYPE_PRECOMPUTE_INIT
6804 | OPTI_TYPE_PRECOMPUTE_MERKLE
6805 | OPTI_TYPE_EARLY_SKIP
6806 | OPTI_TYPE_NOT_ITERATED
6807 | OPTI_TYPE_NOT_SALTED
6808 | OPTI_TYPE_RAW_HASH;
6809 dgst_pos0 = 3;
6810 dgst_pos1 = 4;
6811 dgst_pos2 = 2;
6812 dgst_pos3 = 1;
6813 break;
6814
6815 case 101: hash_type = HASH_TYPE_SHA1;
6816 salt_type = SALT_TYPE_NONE;
6817 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6818 opts_type = OPTS_TYPE_PT_GENERATE_BE
6819 | OPTS_TYPE_PT_ADD80
6820 | OPTS_TYPE_PT_ADDBITS15;
6821 kern_type = KERN_TYPE_SHA1;
6822 dgst_size = DGST_SIZE_4_5;
6823 parse_func = sha1b64_parse_hash;
6824 sort_by_digest = sort_by_digest_4_5;
6825 opti_type = OPTI_TYPE_ZERO_BYTE
6826 | OPTI_TYPE_PRECOMPUTE_INIT
6827 | OPTI_TYPE_PRECOMPUTE_MERKLE
6828 | OPTI_TYPE_EARLY_SKIP
6829 | OPTI_TYPE_NOT_ITERATED
6830 | OPTI_TYPE_NOT_SALTED
6831 | OPTI_TYPE_RAW_HASH;
6832 dgst_pos0 = 3;
6833 dgst_pos1 = 4;
6834 dgst_pos2 = 2;
6835 dgst_pos3 = 1;
6836 break;
6837
6838 case 110: hash_type = HASH_TYPE_SHA1;
6839 salt_type = SALT_TYPE_INTERN;
6840 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6841 opts_type = OPTS_TYPE_PT_GENERATE_BE
6842 | OPTS_TYPE_ST_ADD80
6843 | OPTS_TYPE_ST_ADDBITS15;
6844 kern_type = KERN_TYPE_SHA1_PWSLT;
6845 dgst_size = DGST_SIZE_4_5;
6846 parse_func = sha1s_parse_hash;
6847 sort_by_digest = sort_by_digest_4_5;
6848 opti_type = OPTI_TYPE_ZERO_BYTE
6849 | OPTI_TYPE_PRECOMPUTE_INIT
6850 | OPTI_TYPE_PRECOMPUTE_MERKLE
6851 | OPTI_TYPE_EARLY_SKIP
6852 | OPTI_TYPE_NOT_ITERATED
6853 | OPTI_TYPE_APPENDED_SALT
6854 | OPTI_TYPE_RAW_HASH;
6855 dgst_pos0 = 3;
6856 dgst_pos1 = 4;
6857 dgst_pos2 = 2;
6858 dgst_pos3 = 1;
6859 break;
6860
6861 case 111: hash_type = HASH_TYPE_SHA1;
6862 salt_type = SALT_TYPE_EMBEDDED;
6863 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6864 opts_type = OPTS_TYPE_PT_GENERATE_BE
6865 | OPTS_TYPE_ST_ADD80
6866 | OPTS_TYPE_ST_ADDBITS15;
6867 kern_type = KERN_TYPE_SHA1_PWSLT;
6868 dgst_size = DGST_SIZE_4_5;
6869 parse_func = sha1b64s_parse_hash;
6870 sort_by_digest = sort_by_digest_4_5;
6871 opti_type = OPTI_TYPE_ZERO_BYTE
6872 | OPTI_TYPE_PRECOMPUTE_INIT
6873 | OPTI_TYPE_PRECOMPUTE_MERKLE
6874 | OPTI_TYPE_EARLY_SKIP
6875 | OPTI_TYPE_NOT_ITERATED
6876 | OPTI_TYPE_APPENDED_SALT
6877 | OPTI_TYPE_RAW_HASH;
6878 dgst_pos0 = 3;
6879 dgst_pos1 = 4;
6880 dgst_pos2 = 2;
6881 dgst_pos3 = 1;
6882 break;
6883
6884 case 112: hash_type = HASH_TYPE_SHA1;
6885 salt_type = SALT_TYPE_INTERN;
6886 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6887 opts_type = OPTS_TYPE_PT_GENERATE_BE
6888 | OPTS_TYPE_ST_ADD80
6889 | OPTS_TYPE_ST_ADDBITS15
6890 | OPTS_TYPE_ST_HEX;
6891 kern_type = KERN_TYPE_SHA1_PWSLT;
6892 dgst_size = DGST_SIZE_4_5;
6893 parse_func = oracles_parse_hash;
6894 sort_by_digest = sort_by_digest_4_5;
6895 opti_type = OPTI_TYPE_ZERO_BYTE
6896 | OPTI_TYPE_PRECOMPUTE_INIT
6897 | OPTI_TYPE_PRECOMPUTE_MERKLE
6898 | OPTI_TYPE_EARLY_SKIP
6899 | OPTI_TYPE_NOT_ITERATED
6900 | OPTI_TYPE_APPENDED_SALT
6901 | OPTI_TYPE_RAW_HASH;
6902 dgst_pos0 = 3;
6903 dgst_pos1 = 4;
6904 dgst_pos2 = 2;
6905 dgst_pos3 = 1;
6906 break;
6907
6908 case 120: hash_type = HASH_TYPE_SHA1;
6909 salt_type = SALT_TYPE_INTERN;
6910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6911 opts_type = OPTS_TYPE_PT_GENERATE_BE
6912 | OPTS_TYPE_PT_ADD80
6913 | OPTS_TYPE_PT_ADDBITS15;
6914 kern_type = KERN_TYPE_SHA1_SLTPW;
6915 dgst_size = DGST_SIZE_4_5;
6916 parse_func = sha1s_parse_hash;
6917 sort_by_digest = sort_by_digest_4_5;
6918 opti_type = OPTI_TYPE_ZERO_BYTE
6919 | OPTI_TYPE_PRECOMPUTE_INIT
6920 | OPTI_TYPE_PRECOMPUTE_MERKLE
6921 | OPTI_TYPE_EARLY_SKIP
6922 | OPTI_TYPE_NOT_ITERATED
6923 | OPTI_TYPE_PREPENDED_SALT
6924 | OPTI_TYPE_RAW_HASH;
6925 dgst_pos0 = 3;
6926 dgst_pos1 = 4;
6927 dgst_pos2 = 2;
6928 dgst_pos3 = 1;
6929 break;
6930
6931 case 121: hash_type = HASH_TYPE_SHA1;
6932 salt_type = SALT_TYPE_INTERN;
6933 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6934 opts_type = OPTS_TYPE_PT_GENERATE_BE
6935 | OPTS_TYPE_PT_ADD80
6936 | OPTS_TYPE_PT_ADDBITS15
6937 | OPTS_TYPE_ST_LOWER;
6938 kern_type = KERN_TYPE_SHA1_SLTPW;
6939 dgst_size = DGST_SIZE_4_5;
6940 parse_func = smf_parse_hash;
6941 sort_by_digest = sort_by_digest_4_5;
6942 opti_type = OPTI_TYPE_ZERO_BYTE
6943 | OPTI_TYPE_PRECOMPUTE_INIT
6944 | OPTI_TYPE_PRECOMPUTE_MERKLE
6945 | OPTI_TYPE_EARLY_SKIP
6946 | OPTI_TYPE_NOT_ITERATED
6947 | OPTI_TYPE_PREPENDED_SALT
6948 | OPTI_TYPE_RAW_HASH;
6949 dgst_pos0 = 3;
6950 dgst_pos1 = 4;
6951 dgst_pos2 = 2;
6952 dgst_pos3 = 1;
6953 break;
6954
6955 case 122: hash_type = HASH_TYPE_SHA1;
6956 salt_type = SALT_TYPE_EMBEDDED;
6957 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6958 opts_type = OPTS_TYPE_PT_GENERATE_BE
6959 | OPTS_TYPE_PT_ADD80
6960 | OPTS_TYPE_PT_ADDBITS15
6961 | OPTS_TYPE_ST_HEX;
6962 kern_type = KERN_TYPE_SHA1_SLTPW;
6963 dgst_size = DGST_SIZE_4_5;
6964 parse_func = osx1_parse_hash;
6965 sort_by_digest = sort_by_digest_4_5;
6966 opti_type = OPTI_TYPE_ZERO_BYTE
6967 | OPTI_TYPE_PRECOMPUTE_INIT
6968 | OPTI_TYPE_PRECOMPUTE_MERKLE
6969 | OPTI_TYPE_EARLY_SKIP
6970 | OPTI_TYPE_NOT_ITERATED
6971 | OPTI_TYPE_PREPENDED_SALT
6972 | OPTI_TYPE_RAW_HASH;
6973 dgst_pos0 = 3;
6974 dgst_pos1 = 4;
6975 dgst_pos2 = 2;
6976 dgst_pos3 = 1;
6977 break;
6978
6979 case 124: hash_type = HASH_TYPE_SHA1;
6980 salt_type = SALT_TYPE_EMBEDDED;
6981 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6982 opts_type = OPTS_TYPE_PT_GENERATE_BE
6983 | OPTS_TYPE_PT_ADD80
6984 | OPTS_TYPE_PT_ADDBITS15;
6985 kern_type = KERN_TYPE_SHA1_SLTPW;
6986 dgst_size = DGST_SIZE_4_5;
6987 parse_func = djangosha1_parse_hash;
6988 sort_by_digest = sort_by_digest_4_5;
6989 opti_type = OPTI_TYPE_ZERO_BYTE
6990 | OPTI_TYPE_PRECOMPUTE_INIT
6991 | OPTI_TYPE_PRECOMPUTE_MERKLE
6992 | OPTI_TYPE_EARLY_SKIP
6993 | OPTI_TYPE_NOT_ITERATED
6994 | OPTI_TYPE_PREPENDED_SALT
6995 | OPTI_TYPE_RAW_HASH;
6996 dgst_pos0 = 3;
6997 dgst_pos1 = 4;
6998 dgst_pos2 = 2;
6999 dgst_pos3 = 1;
7000 break;
7001
7002 case 130: hash_type = HASH_TYPE_SHA1;
7003 salt_type = SALT_TYPE_INTERN;
7004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7005 opts_type = OPTS_TYPE_PT_GENERATE_BE
7006 | OPTS_TYPE_PT_UNICODE
7007 | OPTS_TYPE_ST_ADD80
7008 | OPTS_TYPE_ST_ADDBITS15;
7009 kern_type = KERN_TYPE_SHA1_PWUSLT;
7010 dgst_size = DGST_SIZE_4_5;
7011 parse_func = sha1s_parse_hash;
7012 sort_by_digest = sort_by_digest_4_5;
7013 opti_type = OPTI_TYPE_ZERO_BYTE
7014 | OPTI_TYPE_PRECOMPUTE_INIT
7015 | OPTI_TYPE_PRECOMPUTE_MERKLE
7016 | OPTI_TYPE_EARLY_SKIP
7017 | OPTI_TYPE_NOT_ITERATED
7018 | OPTI_TYPE_APPENDED_SALT
7019 | OPTI_TYPE_RAW_HASH;
7020 dgst_pos0 = 3;
7021 dgst_pos1 = 4;
7022 dgst_pos2 = 2;
7023 dgst_pos3 = 1;
7024 break;
7025
7026 case 131: hash_type = HASH_TYPE_SHA1;
7027 salt_type = SALT_TYPE_EMBEDDED;
7028 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7029 opts_type = OPTS_TYPE_PT_GENERATE_BE
7030 | OPTS_TYPE_PT_UNICODE
7031 | OPTS_TYPE_PT_UPPER
7032 | OPTS_TYPE_ST_ADD80
7033 | OPTS_TYPE_ST_ADDBITS15
7034 | OPTS_TYPE_ST_HEX;
7035 kern_type = KERN_TYPE_SHA1_PWUSLT;
7036 dgst_size = DGST_SIZE_4_5;
7037 parse_func = mssql2000_parse_hash;
7038 sort_by_digest = sort_by_digest_4_5;
7039 opti_type = OPTI_TYPE_ZERO_BYTE
7040 | OPTI_TYPE_PRECOMPUTE_INIT
7041 | OPTI_TYPE_PRECOMPUTE_MERKLE
7042 | OPTI_TYPE_EARLY_SKIP
7043 | OPTI_TYPE_NOT_ITERATED
7044 | OPTI_TYPE_APPENDED_SALT
7045 | OPTI_TYPE_RAW_HASH;
7046 dgst_pos0 = 3;
7047 dgst_pos1 = 4;
7048 dgst_pos2 = 2;
7049 dgst_pos3 = 1;
7050 break;
7051
7052 case 132: hash_type = HASH_TYPE_SHA1;
7053 salt_type = SALT_TYPE_EMBEDDED;
7054 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7055 opts_type = OPTS_TYPE_PT_GENERATE_BE
7056 | OPTS_TYPE_PT_UNICODE
7057 | OPTS_TYPE_ST_ADD80
7058 | OPTS_TYPE_ST_ADDBITS15
7059 | OPTS_TYPE_ST_HEX;
7060 kern_type = KERN_TYPE_SHA1_PWUSLT;
7061 dgst_size = DGST_SIZE_4_5;
7062 parse_func = mssql2005_parse_hash;
7063 sort_by_digest = sort_by_digest_4_5;
7064 opti_type = OPTI_TYPE_ZERO_BYTE
7065 | OPTI_TYPE_PRECOMPUTE_INIT
7066 | OPTI_TYPE_PRECOMPUTE_MERKLE
7067 | OPTI_TYPE_EARLY_SKIP
7068 | OPTI_TYPE_NOT_ITERATED
7069 | OPTI_TYPE_APPENDED_SALT
7070 | OPTI_TYPE_RAW_HASH;
7071 dgst_pos0 = 3;
7072 dgst_pos1 = 4;
7073 dgst_pos2 = 2;
7074 dgst_pos3 = 1;
7075 break;
7076
7077 case 133: hash_type = HASH_TYPE_SHA1;
7078 salt_type = SALT_TYPE_EMBEDDED;
7079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7080 opts_type = OPTS_TYPE_PT_GENERATE_BE
7081 | OPTS_TYPE_PT_UNICODE
7082 | OPTS_TYPE_ST_ADD80
7083 | OPTS_TYPE_ST_ADDBITS15;
7084 kern_type = KERN_TYPE_SHA1_PWUSLT;
7085 dgst_size = DGST_SIZE_4_5;
7086 parse_func = peoplesoft_parse_hash;
7087 sort_by_digest = sort_by_digest_4_5;
7088 opti_type = OPTI_TYPE_ZERO_BYTE
7089 | OPTI_TYPE_PRECOMPUTE_INIT
7090 | OPTI_TYPE_PRECOMPUTE_MERKLE
7091 | OPTI_TYPE_EARLY_SKIP
7092 | OPTI_TYPE_NOT_ITERATED
7093 | OPTI_TYPE_APPENDED_SALT
7094 | OPTI_TYPE_RAW_HASH;
7095 dgst_pos0 = 3;
7096 dgst_pos1 = 4;
7097 dgst_pos2 = 2;
7098 dgst_pos3 = 1;
7099 break;
7100
7101 case 140: hash_type = HASH_TYPE_SHA1;
7102 salt_type = SALT_TYPE_INTERN;
7103 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7104 opts_type = OPTS_TYPE_PT_GENERATE_BE
7105 | OPTS_TYPE_PT_ADD80
7106 | OPTS_TYPE_PT_ADDBITS15
7107 | OPTS_TYPE_PT_UNICODE;
7108 kern_type = KERN_TYPE_SHA1_SLTPWU;
7109 dgst_size = DGST_SIZE_4_5;
7110 parse_func = sha1s_parse_hash;
7111 sort_by_digest = sort_by_digest_4_5;
7112 opti_type = OPTI_TYPE_ZERO_BYTE
7113 | OPTI_TYPE_PRECOMPUTE_INIT
7114 | OPTI_TYPE_PRECOMPUTE_MERKLE
7115 | OPTI_TYPE_EARLY_SKIP
7116 | OPTI_TYPE_NOT_ITERATED
7117 | OPTI_TYPE_PREPENDED_SALT
7118 | OPTI_TYPE_RAW_HASH;
7119 dgst_pos0 = 3;
7120 dgst_pos1 = 4;
7121 dgst_pos2 = 2;
7122 dgst_pos3 = 1;
7123 break;
7124
7125 case 141: hash_type = HASH_TYPE_SHA1;
7126 salt_type = SALT_TYPE_EMBEDDED;
7127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7128 opts_type = OPTS_TYPE_PT_GENERATE_BE
7129 | OPTS_TYPE_PT_ADD80
7130 | OPTS_TYPE_PT_ADDBITS15
7131 | OPTS_TYPE_PT_UNICODE
7132 | OPTS_TYPE_ST_BASE64;
7133 kern_type = KERN_TYPE_SHA1_SLTPWU;
7134 dgst_size = DGST_SIZE_4_5;
7135 parse_func = episerver_parse_hash;
7136 sort_by_digest = sort_by_digest_4_5;
7137 opti_type = OPTI_TYPE_ZERO_BYTE
7138 | OPTI_TYPE_PRECOMPUTE_INIT
7139 | OPTI_TYPE_PRECOMPUTE_MERKLE
7140 | OPTI_TYPE_EARLY_SKIP
7141 | OPTI_TYPE_NOT_ITERATED
7142 | OPTI_TYPE_PREPENDED_SALT
7143 | OPTI_TYPE_RAW_HASH;
7144 dgst_pos0 = 3;
7145 dgst_pos1 = 4;
7146 dgst_pos2 = 2;
7147 dgst_pos3 = 1;
7148 break;
7149
7150 case 150: hash_type = HASH_TYPE_SHA1;
7151 salt_type = SALT_TYPE_INTERN;
7152 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7153 opts_type = OPTS_TYPE_PT_GENERATE_BE
7154 | OPTS_TYPE_ST_ADD80
7155 | OPTS_TYPE_ST_ADDBITS15;
7156 kern_type = KERN_TYPE_HMACSHA1_PW;
7157 dgst_size = DGST_SIZE_4_5;
7158 parse_func = hmacsha1_parse_hash;
7159 sort_by_digest = sort_by_digest_4_5;
7160 opti_type = OPTI_TYPE_ZERO_BYTE
7161 | OPTI_TYPE_NOT_ITERATED;
7162 dgst_pos0 = 3;
7163 dgst_pos1 = 4;
7164 dgst_pos2 = 2;
7165 dgst_pos3 = 1;
7166 break;
7167
7168 case 160: hash_type = HASH_TYPE_SHA1;
7169 salt_type = SALT_TYPE_INTERN;
7170 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7171 opts_type = OPTS_TYPE_PT_GENERATE_BE
7172 | OPTS_TYPE_PT_ADD80
7173 | OPTS_TYPE_PT_ADDBITS15;
7174 kern_type = KERN_TYPE_HMACSHA1_SLT;
7175 dgst_size = DGST_SIZE_4_5;
7176 parse_func = hmacsha1_parse_hash;
7177 sort_by_digest = sort_by_digest_4_5;
7178 opti_type = OPTI_TYPE_ZERO_BYTE
7179 | OPTI_TYPE_NOT_ITERATED;
7180 dgst_pos0 = 3;
7181 dgst_pos1 = 4;
7182 dgst_pos2 = 2;
7183 dgst_pos3 = 1;
7184 break;
7185
7186 case 190: hash_type = HASH_TYPE_SHA1;
7187 salt_type = SALT_TYPE_NONE;
7188 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7189 opts_type = OPTS_TYPE_PT_GENERATE_BE
7190 | OPTS_TYPE_PT_ADD80
7191 | OPTS_TYPE_PT_ADDBITS15;
7192 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7193 dgst_size = DGST_SIZE_4_5;
7194 parse_func = sha1linkedin_parse_hash;
7195 sort_by_digest = sort_by_digest_4_5;
7196 opti_type = OPTI_TYPE_ZERO_BYTE
7197 | OPTI_TYPE_PRECOMPUTE_INIT
7198 | OPTI_TYPE_EARLY_SKIP
7199 | OPTI_TYPE_NOT_ITERATED
7200 | OPTI_TYPE_NOT_SALTED;
7201 dgst_pos0 = 0;
7202 dgst_pos1 = 4;
7203 dgst_pos2 = 3;
7204 dgst_pos3 = 2;
7205 break;
7206
7207 case 200: hash_type = HASH_TYPE_MYSQL;
7208 salt_type = SALT_TYPE_NONE;
7209 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7210 opts_type = 0;
7211 kern_type = KERN_TYPE_MYSQL;
7212 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7213 parse_func = mysql323_parse_hash;
7214 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7215 opti_type = OPTI_TYPE_ZERO_BYTE;
7216 dgst_pos0 = 0;
7217 dgst_pos1 = 1;
7218 dgst_pos2 = 2;
7219 dgst_pos3 = 3;
7220 break;
7221
7222 case 300: hash_type = HASH_TYPE_SHA1;
7223 salt_type = SALT_TYPE_NONE;
7224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7225 opts_type = OPTS_TYPE_PT_GENERATE_BE
7226 | OPTS_TYPE_PT_ADD80
7227 | OPTS_TYPE_PT_ADDBITS15;
7228 kern_type = KERN_TYPE_MYSQL41;
7229 dgst_size = DGST_SIZE_4_5;
7230 parse_func = sha1_parse_hash;
7231 sort_by_digest = sort_by_digest_4_5;
7232 opti_type = OPTI_TYPE_ZERO_BYTE
7233 | OPTI_TYPE_PRECOMPUTE_INIT
7234 | OPTI_TYPE_PRECOMPUTE_MERKLE
7235 | OPTI_TYPE_EARLY_SKIP
7236 | OPTI_TYPE_NOT_ITERATED
7237 | OPTI_TYPE_NOT_SALTED;
7238 dgst_pos0 = 3;
7239 dgst_pos1 = 4;
7240 dgst_pos2 = 2;
7241 dgst_pos3 = 1;
7242 break;
7243
7244 case 400: hash_type = HASH_TYPE_MD5;
7245 salt_type = SALT_TYPE_EMBEDDED;
7246 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7247 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7248 kern_type = KERN_TYPE_PHPASS;
7249 dgst_size = DGST_SIZE_4_4;
7250 parse_func = phpass_parse_hash;
7251 sort_by_digest = sort_by_digest_4_4;
7252 opti_type = OPTI_TYPE_ZERO_BYTE;
7253 dgst_pos0 = 0;
7254 dgst_pos1 = 1;
7255 dgst_pos2 = 2;
7256 dgst_pos3 = 3;
7257 break;
7258
7259 case 500: hash_type = HASH_TYPE_MD5;
7260 salt_type = SALT_TYPE_EMBEDDED;
7261 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7262 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7263 kern_type = KERN_TYPE_MD5CRYPT;
7264 dgst_size = DGST_SIZE_4_4;
7265 parse_func = md5crypt_parse_hash;
7266 sort_by_digest = sort_by_digest_4_4;
7267 opti_type = OPTI_TYPE_ZERO_BYTE;
7268 dgst_pos0 = 0;
7269 dgst_pos1 = 1;
7270 dgst_pos2 = 2;
7271 dgst_pos3 = 3;
7272 break;
7273
7274 case 501: hash_type = HASH_TYPE_MD5;
7275 salt_type = SALT_TYPE_EMBEDDED;
7276 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7277 opts_type = OPTS_TYPE_PT_GENERATE_LE
7278 | OPTS_TYPE_HASH_COPY;
7279 kern_type = KERN_TYPE_MD5CRYPT;
7280 dgst_size = DGST_SIZE_4_4;
7281 parse_func = juniper_parse_hash;
7282 sort_by_digest = sort_by_digest_4_4;
7283 opti_type = OPTI_TYPE_ZERO_BYTE;
7284 dgst_pos0 = 0;
7285 dgst_pos1 = 1;
7286 dgst_pos2 = 2;
7287 dgst_pos3 = 3;
7288 break;
7289
7290 case 900: hash_type = HASH_TYPE_MD4;
7291 salt_type = SALT_TYPE_NONE;
7292 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7293 opts_type = OPTS_TYPE_PT_GENERATE_LE
7294 | OPTS_TYPE_PT_ADD80
7295 | OPTS_TYPE_PT_ADDBITS14;
7296 kern_type = KERN_TYPE_MD4;
7297 dgst_size = DGST_SIZE_4_4;
7298 parse_func = md4_parse_hash;
7299 sort_by_digest = sort_by_digest_4_4;
7300 opti_type = OPTI_TYPE_ZERO_BYTE
7301 | OPTI_TYPE_PRECOMPUTE_INIT
7302 | OPTI_TYPE_PRECOMPUTE_MERKLE
7303 | OPTI_TYPE_MEET_IN_MIDDLE
7304 | OPTI_TYPE_EARLY_SKIP
7305 | OPTI_TYPE_NOT_ITERATED
7306 | OPTI_TYPE_NOT_SALTED
7307 | OPTI_TYPE_RAW_HASH;
7308 dgst_pos0 = 0;
7309 dgst_pos1 = 3;
7310 dgst_pos2 = 2;
7311 dgst_pos3 = 1;
7312 break;
7313
7314 case 1000: hash_type = HASH_TYPE_MD4;
7315 salt_type = SALT_TYPE_NONE;
7316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7317 opts_type = OPTS_TYPE_PT_GENERATE_LE
7318 | OPTS_TYPE_PT_ADD80
7319 | OPTS_TYPE_PT_ADDBITS14
7320 | OPTS_TYPE_PT_UNICODE;
7321 kern_type = KERN_TYPE_MD4_PWU;
7322 dgst_size = DGST_SIZE_4_4;
7323 parse_func = md4_parse_hash;
7324 sort_by_digest = sort_by_digest_4_4;
7325 opti_type = OPTI_TYPE_ZERO_BYTE
7326 | OPTI_TYPE_PRECOMPUTE_INIT
7327 | OPTI_TYPE_PRECOMPUTE_MERKLE
7328 | OPTI_TYPE_MEET_IN_MIDDLE
7329 | OPTI_TYPE_EARLY_SKIP
7330 | OPTI_TYPE_NOT_ITERATED
7331 | OPTI_TYPE_NOT_SALTED
7332 | OPTI_TYPE_RAW_HASH;
7333 dgst_pos0 = 0;
7334 dgst_pos1 = 3;
7335 dgst_pos2 = 2;
7336 dgst_pos3 = 1;
7337 break;
7338
7339 case 1100: hash_type = HASH_TYPE_MD4;
7340 salt_type = SALT_TYPE_INTERN;
7341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7342 opts_type = OPTS_TYPE_PT_GENERATE_LE
7343 | OPTS_TYPE_PT_ADD80
7344 | OPTS_TYPE_PT_ADDBITS14
7345 | OPTS_TYPE_PT_UNICODE
7346 | OPTS_TYPE_ST_ADD80
7347 | OPTS_TYPE_ST_UNICODE
7348 | OPTS_TYPE_ST_LOWER;
7349 kern_type = KERN_TYPE_MD44_PWUSLT;
7350 dgst_size = DGST_SIZE_4_4;
7351 parse_func = dcc_parse_hash;
7352 sort_by_digest = sort_by_digest_4_4;
7353 opti_type = OPTI_TYPE_ZERO_BYTE
7354 | OPTI_TYPE_PRECOMPUTE_INIT
7355 | OPTI_TYPE_PRECOMPUTE_MERKLE
7356 | OPTI_TYPE_EARLY_SKIP
7357 | OPTI_TYPE_NOT_ITERATED;
7358 dgst_pos0 = 0;
7359 dgst_pos1 = 3;
7360 dgst_pos2 = 2;
7361 dgst_pos3 = 1;
7362 break;
7363
7364 case 1400: hash_type = HASH_TYPE_SHA256;
7365 salt_type = SALT_TYPE_NONE;
7366 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7367 opts_type = OPTS_TYPE_PT_GENERATE_BE
7368 | OPTS_TYPE_PT_ADD80
7369 | OPTS_TYPE_PT_ADDBITS15;
7370 kern_type = KERN_TYPE_SHA256;
7371 dgst_size = DGST_SIZE_4_8;
7372 parse_func = sha256_parse_hash;
7373 sort_by_digest = sort_by_digest_4_8;
7374 opti_type = OPTI_TYPE_ZERO_BYTE
7375 | OPTI_TYPE_PRECOMPUTE_INIT
7376 | OPTI_TYPE_PRECOMPUTE_MERKLE
7377 | OPTI_TYPE_EARLY_SKIP
7378 | OPTI_TYPE_NOT_ITERATED
7379 | OPTI_TYPE_NOT_SALTED
7380 | OPTI_TYPE_RAW_HASH;
7381 dgst_pos0 = 3;
7382 dgst_pos1 = 7;
7383 dgst_pos2 = 2;
7384 dgst_pos3 = 6;
7385 break;
7386
7387 case 1410: hash_type = HASH_TYPE_SHA256;
7388 salt_type = SALT_TYPE_INTERN;
7389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7390 opts_type = OPTS_TYPE_PT_GENERATE_BE
7391 | OPTS_TYPE_ST_ADD80
7392 | OPTS_TYPE_ST_ADDBITS15;
7393 kern_type = KERN_TYPE_SHA256_PWSLT;
7394 dgst_size = DGST_SIZE_4_8;
7395 parse_func = sha256s_parse_hash;
7396 sort_by_digest = sort_by_digest_4_8;
7397 opti_type = OPTI_TYPE_ZERO_BYTE
7398 | OPTI_TYPE_PRECOMPUTE_INIT
7399 | OPTI_TYPE_PRECOMPUTE_MERKLE
7400 | OPTI_TYPE_EARLY_SKIP
7401 | OPTI_TYPE_NOT_ITERATED
7402 | OPTI_TYPE_APPENDED_SALT
7403 | OPTI_TYPE_RAW_HASH;
7404 dgst_pos0 = 3;
7405 dgst_pos1 = 7;
7406 dgst_pos2 = 2;
7407 dgst_pos3 = 6;
7408 break;
7409
7410 case 1420: hash_type = HASH_TYPE_SHA256;
7411 salt_type = SALT_TYPE_INTERN;
7412 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7413 opts_type = OPTS_TYPE_PT_GENERATE_BE
7414 | OPTS_TYPE_PT_ADD80
7415 | OPTS_TYPE_PT_ADDBITS15;
7416 kern_type = KERN_TYPE_SHA256_SLTPW;
7417 dgst_size = DGST_SIZE_4_8;
7418 parse_func = sha256s_parse_hash;
7419 sort_by_digest = sort_by_digest_4_8;
7420 opti_type = OPTI_TYPE_ZERO_BYTE
7421 | OPTI_TYPE_PRECOMPUTE_INIT
7422 | OPTI_TYPE_PRECOMPUTE_MERKLE
7423 | OPTI_TYPE_EARLY_SKIP
7424 | OPTI_TYPE_NOT_ITERATED
7425 | OPTI_TYPE_PREPENDED_SALT
7426 | OPTI_TYPE_RAW_HASH;
7427 dgst_pos0 = 3;
7428 dgst_pos1 = 7;
7429 dgst_pos2 = 2;
7430 dgst_pos3 = 6;
7431 break;
7432
7433 case 1421: hash_type = HASH_TYPE_SHA256;
7434 salt_type = SALT_TYPE_EMBEDDED;
7435 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7436 opts_type = OPTS_TYPE_PT_GENERATE_BE
7437 | OPTS_TYPE_PT_ADD80
7438 | OPTS_TYPE_PT_ADDBITS15;
7439 kern_type = KERN_TYPE_SHA256_SLTPW;
7440 dgst_size = DGST_SIZE_4_8;
7441 parse_func = hmailserver_parse_hash;
7442 sort_by_digest = sort_by_digest_4_8;
7443 opti_type = OPTI_TYPE_ZERO_BYTE
7444 | OPTI_TYPE_PRECOMPUTE_INIT
7445 | OPTI_TYPE_PRECOMPUTE_MERKLE
7446 | OPTI_TYPE_EARLY_SKIP
7447 | OPTI_TYPE_NOT_ITERATED
7448 | OPTI_TYPE_PREPENDED_SALT
7449 | OPTI_TYPE_RAW_HASH;
7450 dgst_pos0 = 3;
7451 dgst_pos1 = 7;
7452 dgst_pos2 = 2;
7453 dgst_pos3 = 6;
7454 break;
7455
7456 case 1430: hash_type = HASH_TYPE_SHA256;
7457 salt_type = SALT_TYPE_INTERN;
7458 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7459 opts_type = OPTS_TYPE_PT_GENERATE_BE
7460 | OPTS_TYPE_PT_UNICODE
7461 | OPTS_TYPE_ST_ADD80
7462 | OPTS_TYPE_ST_ADDBITS15;
7463 kern_type = KERN_TYPE_SHA256_PWUSLT;
7464 dgst_size = DGST_SIZE_4_8;
7465 parse_func = sha256s_parse_hash;
7466 sort_by_digest = sort_by_digest_4_8;
7467 opti_type = OPTI_TYPE_ZERO_BYTE
7468 | OPTI_TYPE_PRECOMPUTE_INIT
7469 | OPTI_TYPE_PRECOMPUTE_MERKLE
7470 | OPTI_TYPE_EARLY_SKIP
7471 | OPTI_TYPE_NOT_ITERATED
7472 | OPTI_TYPE_APPENDED_SALT
7473 | OPTI_TYPE_RAW_HASH;
7474 dgst_pos0 = 3;
7475 dgst_pos1 = 7;
7476 dgst_pos2 = 2;
7477 dgst_pos3 = 6;
7478 break;
7479
7480 case 1440: hash_type = HASH_TYPE_SHA256;
7481 salt_type = SALT_TYPE_INTERN;
7482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7483 opts_type = OPTS_TYPE_PT_GENERATE_BE
7484 | OPTS_TYPE_PT_ADD80
7485 | OPTS_TYPE_PT_ADDBITS15
7486 | OPTS_TYPE_PT_UNICODE;
7487 kern_type = KERN_TYPE_SHA256_SLTPWU;
7488 dgst_size = DGST_SIZE_4_8;
7489 parse_func = sha256s_parse_hash;
7490 sort_by_digest = sort_by_digest_4_8;
7491 opti_type = OPTI_TYPE_ZERO_BYTE
7492 | OPTI_TYPE_PRECOMPUTE_INIT
7493 | OPTI_TYPE_PRECOMPUTE_MERKLE
7494 | OPTI_TYPE_EARLY_SKIP
7495 | OPTI_TYPE_NOT_ITERATED
7496 | OPTI_TYPE_PREPENDED_SALT
7497 | OPTI_TYPE_RAW_HASH;
7498 dgst_pos0 = 3;
7499 dgst_pos1 = 7;
7500 dgst_pos2 = 2;
7501 dgst_pos3 = 6;
7502 break;
7503
7504 case 1441: hash_type = HASH_TYPE_SHA256;
7505 salt_type = SALT_TYPE_EMBEDDED;
7506 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7507 opts_type = OPTS_TYPE_PT_GENERATE_BE
7508 | OPTS_TYPE_PT_ADD80
7509 | OPTS_TYPE_PT_ADDBITS15
7510 | OPTS_TYPE_PT_UNICODE
7511 | OPTS_TYPE_ST_BASE64;
7512 kern_type = KERN_TYPE_SHA256_SLTPWU;
7513 dgst_size = DGST_SIZE_4_8;
7514 parse_func = episerver4_parse_hash;
7515 sort_by_digest = sort_by_digest_4_8;
7516 opti_type = OPTI_TYPE_ZERO_BYTE
7517 | OPTI_TYPE_PRECOMPUTE_INIT
7518 | OPTI_TYPE_PRECOMPUTE_MERKLE
7519 | OPTI_TYPE_EARLY_SKIP
7520 | OPTI_TYPE_NOT_ITERATED
7521 | OPTI_TYPE_PREPENDED_SALT
7522 | OPTI_TYPE_RAW_HASH;
7523 dgst_pos0 = 3;
7524 dgst_pos1 = 7;
7525 dgst_pos2 = 2;
7526 dgst_pos3 = 6;
7527 break;
7528
7529 case 1450: hash_type = HASH_TYPE_SHA256;
7530 salt_type = SALT_TYPE_INTERN;
7531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7532 opts_type = OPTS_TYPE_PT_GENERATE_BE
7533 | OPTS_TYPE_ST_ADD80;
7534 kern_type = KERN_TYPE_HMACSHA256_PW;
7535 dgst_size = DGST_SIZE_4_8;
7536 parse_func = hmacsha256_parse_hash;
7537 sort_by_digest = sort_by_digest_4_8;
7538 opti_type = OPTI_TYPE_ZERO_BYTE
7539 | OPTI_TYPE_NOT_ITERATED;
7540 dgst_pos0 = 3;
7541 dgst_pos1 = 7;
7542 dgst_pos2 = 2;
7543 dgst_pos3 = 6;
7544 break;
7545
7546 case 1460: hash_type = HASH_TYPE_SHA256;
7547 salt_type = SALT_TYPE_INTERN;
7548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7549 opts_type = OPTS_TYPE_PT_GENERATE_BE
7550 | OPTS_TYPE_PT_ADD80
7551 | OPTS_TYPE_PT_ADDBITS15;
7552 kern_type = KERN_TYPE_HMACSHA256_SLT;
7553 dgst_size = DGST_SIZE_4_8;
7554 parse_func = hmacsha256_parse_hash;
7555 sort_by_digest = sort_by_digest_4_8;
7556 opti_type = OPTI_TYPE_ZERO_BYTE
7557 | OPTI_TYPE_NOT_ITERATED;
7558 dgst_pos0 = 3;
7559 dgst_pos1 = 7;
7560 dgst_pos2 = 2;
7561 dgst_pos3 = 6;
7562 break;
7563
7564 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7565 salt_type = SALT_TYPE_EMBEDDED;
7566 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7567 opts_type = OPTS_TYPE_PT_GENERATE_LE
7568 | OPTS_TYPE_PT_BITSLICE;
7569 kern_type = KERN_TYPE_DESCRYPT;
7570 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7571 parse_func = descrypt_parse_hash;
7572 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7573 opti_type = OPTI_TYPE_ZERO_BYTE
7574 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7575 dgst_pos0 = 0;
7576 dgst_pos1 = 1;
7577 dgst_pos2 = 2;
7578 dgst_pos3 = 3;
7579 break;
7580
7581 case 1600: hash_type = HASH_TYPE_MD5;
7582 salt_type = SALT_TYPE_EMBEDDED;
7583 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7584 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7585 kern_type = KERN_TYPE_APR1CRYPT;
7586 dgst_size = DGST_SIZE_4_4;
7587 parse_func = md5apr1_parse_hash;
7588 sort_by_digest = sort_by_digest_4_4;
7589 opti_type = OPTI_TYPE_ZERO_BYTE;
7590 dgst_pos0 = 0;
7591 dgst_pos1 = 1;
7592 dgst_pos2 = 2;
7593 dgst_pos3 = 3;
7594 break;
7595
7596 case 1700: hash_type = HASH_TYPE_SHA512;
7597 salt_type = SALT_TYPE_NONE;
7598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7599 opts_type = OPTS_TYPE_PT_GENERATE_BE
7600 | OPTS_TYPE_PT_ADD80
7601 | OPTS_TYPE_PT_ADDBITS15;
7602 kern_type = KERN_TYPE_SHA512;
7603 dgst_size = DGST_SIZE_8_8;
7604 parse_func = sha512_parse_hash;
7605 sort_by_digest = sort_by_digest_8_8;
7606 opti_type = OPTI_TYPE_ZERO_BYTE
7607 | OPTI_TYPE_PRECOMPUTE_INIT
7608 | OPTI_TYPE_PRECOMPUTE_MERKLE
7609 | OPTI_TYPE_EARLY_SKIP
7610 | OPTI_TYPE_NOT_ITERATED
7611 | OPTI_TYPE_NOT_SALTED
7612 | OPTI_TYPE_RAW_HASH;
7613 dgst_pos0 = 14;
7614 dgst_pos1 = 15;
7615 dgst_pos2 = 6;
7616 dgst_pos3 = 7;
7617 break;
7618
7619 case 1710: hash_type = HASH_TYPE_SHA512;
7620 salt_type = SALT_TYPE_INTERN;
7621 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7622 opts_type = OPTS_TYPE_PT_GENERATE_BE
7623 | OPTS_TYPE_ST_ADD80
7624 | OPTS_TYPE_ST_ADDBITS15;
7625 kern_type = KERN_TYPE_SHA512_PWSLT;
7626 dgst_size = DGST_SIZE_8_8;
7627 parse_func = sha512s_parse_hash;
7628 sort_by_digest = sort_by_digest_8_8;
7629 opti_type = OPTI_TYPE_ZERO_BYTE
7630 | OPTI_TYPE_PRECOMPUTE_INIT
7631 | OPTI_TYPE_PRECOMPUTE_MERKLE
7632 | OPTI_TYPE_EARLY_SKIP
7633 | OPTI_TYPE_NOT_ITERATED
7634 | OPTI_TYPE_APPENDED_SALT
7635 | OPTI_TYPE_RAW_HASH;
7636 dgst_pos0 = 14;
7637 dgst_pos1 = 15;
7638 dgst_pos2 = 6;
7639 dgst_pos3 = 7;
7640 break;
7641
7642 case 1711: hash_type = HASH_TYPE_SHA512;
7643 salt_type = SALT_TYPE_EMBEDDED;
7644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7645 opts_type = OPTS_TYPE_PT_GENERATE_BE
7646 | OPTS_TYPE_ST_ADD80
7647 | OPTS_TYPE_ST_ADDBITS15;
7648 kern_type = KERN_TYPE_SHA512_PWSLT;
7649 dgst_size = DGST_SIZE_8_8;
7650 parse_func = sha512b64s_parse_hash;
7651 sort_by_digest = sort_by_digest_8_8;
7652 opti_type = OPTI_TYPE_ZERO_BYTE
7653 | OPTI_TYPE_PRECOMPUTE_INIT
7654 | OPTI_TYPE_PRECOMPUTE_MERKLE
7655 | OPTI_TYPE_EARLY_SKIP
7656 | OPTI_TYPE_NOT_ITERATED
7657 | OPTI_TYPE_APPENDED_SALT
7658 | OPTI_TYPE_RAW_HASH;
7659 dgst_pos0 = 14;
7660 dgst_pos1 = 15;
7661 dgst_pos2 = 6;
7662 dgst_pos3 = 7;
7663 break;
7664
7665 case 1720: hash_type = HASH_TYPE_SHA512;
7666 salt_type = SALT_TYPE_INTERN;
7667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7668 opts_type = OPTS_TYPE_PT_GENERATE_BE
7669 | OPTS_TYPE_PT_ADD80
7670 | OPTS_TYPE_PT_ADDBITS15;
7671 kern_type = KERN_TYPE_SHA512_SLTPW;
7672 dgst_size = DGST_SIZE_8_8;
7673 parse_func = sha512s_parse_hash;
7674 sort_by_digest = sort_by_digest_8_8;
7675 opti_type = OPTI_TYPE_ZERO_BYTE
7676 | OPTI_TYPE_PRECOMPUTE_INIT
7677 | OPTI_TYPE_PRECOMPUTE_MERKLE
7678 | OPTI_TYPE_EARLY_SKIP
7679 | OPTI_TYPE_NOT_ITERATED
7680 | OPTI_TYPE_PREPENDED_SALT
7681 | OPTI_TYPE_RAW_HASH;
7682 dgst_pos0 = 14;
7683 dgst_pos1 = 15;
7684 dgst_pos2 = 6;
7685 dgst_pos3 = 7;
7686 break;
7687
7688 case 1722: hash_type = HASH_TYPE_SHA512;
7689 salt_type = SALT_TYPE_EMBEDDED;
7690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7691 opts_type = OPTS_TYPE_PT_GENERATE_BE
7692 | OPTS_TYPE_PT_ADD80
7693 | OPTS_TYPE_PT_ADDBITS15
7694 | OPTS_TYPE_ST_HEX;
7695 kern_type = KERN_TYPE_SHA512_SLTPW;
7696 dgst_size = DGST_SIZE_8_8;
7697 parse_func = osx512_parse_hash;
7698 sort_by_digest = sort_by_digest_8_8;
7699 opti_type = OPTI_TYPE_ZERO_BYTE
7700 | OPTI_TYPE_PRECOMPUTE_INIT
7701 | OPTI_TYPE_PRECOMPUTE_MERKLE
7702 | OPTI_TYPE_EARLY_SKIP
7703 | OPTI_TYPE_NOT_ITERATED
7704 | OPTI_TYPE_PREPENDED_SALT
7705 | OPTI_TYPE_RAW_HASH;
7706 dgst_pos0 = 14;
7707 dgst_pos1 = 15;
7708 dgst_pos2 = 6;
7709 dgst_pos3 = 7;
7710 break;
7711
7712 case 1730: hash_type = HASH_TYPE_SHA512;
7713 salt_type = SALT_TYPE_INTERN;
7714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7715 opts_type = OPTS_TYPE_PT_GENERATE_BE
7716 | OPTS_TYPE_PT_UNICODE
7717 | OPTS_TYPE_ST_ADD80
7718 | OPTS_TYPE_ST_ADDBITS15;
7719 kern_type = KERN_TYPE_SHA512_PWSLTU;
7720 dgst_size = DGST_SIZE_8_8;
7721 parse_func = sha512s_parse_hash;
7722 sort_by_digest = sort_by_digest_8_8;
7723 opti_type = OPTI_TYPE_ZERO_BYTE
7724 | OPTI_TYPE_PRECOMPUTE_INIT
7725 | OPTI_TYPE_PRECOMPUTE_MERKLE
7726 | OPTI_TYPE_EARLY_SKIP
7727 | OPTI_TYPE_NOT_ITERATED
7728 | OPTI_TYPE_APPENDED_SALT
7729 | OPTI_TYPE_RAW_HASH;
7730 dgst_pos0 = 14;
7731 dgst_pos1 = 15;
7732 dgst_pos2 = 6;
7733 dgst_pos3 = 7;
7734 break;
7735
7736 case 1731: hash_type = HASH_TYPE_SHA512;
7737 salt_type = SALT_TYPE_EMBEDDED;
7738 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7739 opts_type = OPTS_TYPE_PT_GENERATE_BE
7740 | OPTS_TYPE_PT_UNICODE
7741 | OPTS_TYPE_ST_ADD80
7742 | OPTS_TYPE_ST_ADDBITS15
7743 | OPTS_TYPE_ST_HEX;
7744 kern_type = KERN_TYPE_SHA512_PWSLTU;
7745 dgst_size = DGST_SIZE_8_8;
7746 parse_func = mssql2012_parse_hash;
7747 sort_by_digest = sort_by_digest_8_8;
7748 opti_type = OPTI_TYPE_ZERO_BYTE
7749 | OPTI_TYPE_PRECOMPUTE_INIT
7750 | OPTI_TYPE_PRECOMPUTE_MERKLE
7751 | OPTI_TYPE_EARLY_SKIP
7752 | OPTI_TYPE_NOT_ITERATED
7753 | OPTI_TYPE_APPENDED_SALT
7754 | OPTI_TYPE_RAW_HASH;
7755 dgst_pos0 = 14;
7756 dgst_pos1 = 15;
7757 dgst_pos2 = 6;
7758 dgst_pos3 = 7;
7759 break;
7760
7761 case 1740: hash_type = HASH_TYPE_SHA512;
7762 salt_type = SALT_TYPE_INTERN;
7763 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7764 opts_type = OPTS_TYPE_PT_GENERATE_BE
7765 | OPTS_TYPE_PT_ADD80
7766 | OPTS_TYPE_PT_ADDBITS15
7767 | OPTS_TYPE_PT_UNICODE;
7768 kern_type = KERN_TYPE_SHA512_SLTPWU;
7769 dgst_size = DGST_SIZE_8_8;
7770 parse_func = sha512s_parse_hash;
7771 sort_by_digest = sort_by_digest_8_8;
7772 opti_type = OPTI_TYPE_ZERO_BYTE
7773 | OPTI_TYPE_PRECOMPUTE_INIT
7774 | OPTI_TYPE_PRECOMPUTE_MERKLE
7775 | OPTI_TYPE_EARLY_SKIP
7776 | OPTI_TYPE_NOT_ITERATED
7777 | OPTI_TYPE_PREPENDED_SALT
7778 | OPTI_TYPE_RAW_HASH;
7779 dgst_pos0 = 14;
7780 dgst_pos1 = 15;
7781 dgst_pos2 = 6;
7782 dgst_pos3 = 7;
7783 break;
7784
7785 case 1750: hash_type = HASH_TYPE_SHA512;
7786 salt_type = SALT_TYPE_INTERN;
7787 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7788 opts_type = OPTS_TYPE_PT_GENERATE_BE
7789 | OPTS_TYPE_ST_ADD80;
7790 kern_type = KERN_TYPE_HMACSHA512_PW;
7791 dgst_size = DGST_SIZE_8_8;
7792 parse_func = hmacsha512_parse_hash;
7793 sort_by_digest = sort_by_digest_8_8;
7794 opti_type = OPTI_TYPE_ZERO_BYTE
7795 | OPTI_TYPE_NOT_ITERATED;
7796 dgst_pos0 = 14;
7797 dgst_pos1 = 15;
7798 dgst_pos2 = 6;
7799 dgst_pos3 = 7;
7800 break;
7801
7802 case 1760: hash_type = HASH_TYPE_SHA512;
7803 salt_type = SALT_TYPE_INTERN;
7804 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7805 opts_type = OPTS_TYPE_PT_GENERATE_BE
7806 | OPTS_TYPE_PT_ADD80
7807 | OPTS_TYPE_PT_ADDBITS15;
7808 kern_type = KERN_TYPE_HMACSHA512_SLT;
7809 dgst_size = DGST_SIZE_8_8;
7810 parse_func = hmacsha512_parse_hash;
7811 sort_by_digest = sort_by_digest_8_8;
7812 opti_type = OPTI_TYPE_ZERO_BYTE
7813 | OPTI_TYPE_NOT_ITERATED;
7814 dgst_pos0 = 14;
7815 dgst_pos1 = 15;
7816 dgst_pos2 = 6;
7817 dgst_pos3 = 7;
7818 break;
7819
7820 case 1800: hash_type = HASH_TYPE_SHA512;
7821 salt_type = SALT_TYPE_EMBEDDED;
7822 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7823 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7824 kern_type = KERN_TYPE_SHA512CRYPT;
7825 dgst_size = DGST_SIZE_8_8;
7826 parse_func = sha512crypt_parse_hash;
7827 sort_by_digest = sort_by_digest_8_8;
7828 opti_type = OPTI_TYPE_ZERO_BYTE;
7829 dgst_pos0 = 0;
7830 dgst_pos1 = 1;
7831 dgst_pos2 = 2;
7832 dgst_pos3 = 3;
7833 break;
7834
7835 case 2100: hash_type = HASH_TYPE_DCC2;
7836 salt_type = SALT_TYPE_EMBEDDED;
7837 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7838 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7839 | OPTS_TYPE_ST_LOWER
7840 | OPTS_TYPE_ST_UNICODE;
7841 kern_type = KERN_TYPE_DCC2;
7842 dgst_size = DGST_SIZE_4_4;
7843 parse_func = dcc2_parse_hash;
7844 sort_by_digest = sort_by_digest_4_4;
7845 opti_type = OPTI_TYPE_ZERO_BYTE;
7846 dgst_pos0 = 0;
7847 dgst_pos1 = 1;
7848 dgst_pos2 = 2;
7849 dgst_pos3 = 3;
7850 break;
7851
7852 case 2400: hash_type = HASH_TYPE_MD5;
7853 salt_type = SALT_TYPE_NONE;
7854 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7855 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7856 kern_type = KERN_TYPE_MD5PIX;
7857 dgst_size = DGST_SIZE_4_4;
7858 parse_func = md5pix_parse_hash;
7859 sort_by_digest = sort_by_digest_4_4;
7860 opti_type = OPTI_TYPE_ZERO_BYTE
7861 | OPTI_TYPE_PRECOMPUTE_INIT
7862 | OPTI_TYPE_PRECOMPUTE_MERKLE
7863 | OPTI_TYPE_EARLY_SKIP
7864 | OPTI_TYPE_NOT_ITERATED
7865 | OPTI_TYPE_NOT_SALTED;
7866 dgst_pos0 = 0;
7867 dgst_pos1 = 3;
7868 dgst_pos2 = 2;
7869 dgst_pos3 = 1;
7870 break;
7871
7872 case 2410: hash_type = HASH_TYPE_MD5;
7873 salt_type = SALT_TYPE_INTERN;
7874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7875 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7876 kern_type = KERN_TYPE_MD5ASA;
7877 dgst_size = DGST_SIZE_4_4;
7878 parse_func = md5asa_parse_hash;
7879 sort_by_digest = sort_by_digest_4_4;
7880 opti_type = OPTI_TYPE_ZERO_BYTE
7881 | OPTI_TYPE_PRECOMPUTE_INIT
7882 | OPTI_TYPE_PRECOMPUTE_MERKLE
7883 | OPTI_TYPE_EARLY_SKIP
7884 | OPTI_TYPE_NOT_ITERATED;
7885 dgst_pos0 = 0;
7886 dgst_pos1 = 3;
7887 dgst_pos2 = 2;
7888 dgst_pos3 = 1;
7889 break;
7890
7891 case 2500: hash_type = HASH_TYPE_WPA;
7892 salt_type = SALT_TYPE_EMBEDDED;
7893 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7894 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7895 kern_type = KERN_TYPE_WPA;
7896 dgst_size = DGST_SIZE_4_4;
7897 parse_func = wpa_parse_hash;
7898 sort_by_digest = sort_by_digest_4_4;
7899 opti_type = OPTI_TYPE_ZERO_BYTE;
7900 dgst_pos0 = 0;
7901 dgst_pos1 = 1;
7902 dgst_pos2 = 2;
7903 dgst_pos3 = 3;
7904 break;
7905
7906 case 2600: hash_type = HASH_TYPE_MD5;
7907 salt_type = SALT_TYPE_VIRTUAL;
7908 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7909 opts_type = OPTS_TYPE_PT_GENERATE_LE
7910 | OPTS_TYPE_PT_ADD80
7911 | OPTS_TYPE_PT_ADDBITS14
7912 | OPTS_TYPE_ST_ADD80;
7913 kern_type = KERN_TYPE_MD55_PWSLT1;
7914 dgst_size = DGST_SIZE_4_4;
7915 parse_func = md5md5_parse_hash;
7916 sort_by_digest = sort_by_digest_4_4;
7917 opti_type = OPTI_TYPE_ZERO_BYTE
7918 | OPTI_TYPE_PRECOMPUTE_INIT
7919 | OPTI_TYPE_PRECOMPUTE_MERKLE
7920 | OPTI_TYPE_EARLY_SKIP;
7921 dgst_pos0 = 0;
7922 dgst_pos1 = 3;
7923 dgst_pos2 = 2;
7924 dgst_pos3 = 1;
7925 break;
7926
7927 case 2611: hash_type = HASH_TYPE_MD5;
7928 salt_type = SALT_TYPE_INTERN;
7929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7930 opts_type = OPTS_TYPE_PT_GENERATE_LE
7931 | OPTS_TYPE_PT_ADD80
7932 | OPTS_TYPE_PT_ADDBITS14
7933 | OPTS_TYPE_ST_ADD80;
7934 kern_type = KERN_TYPE_MD55_PWSLT1;
7935 dgst_size = DGST_SIZE_4_4;
7936 parse_func = vb3_parse_hash;
7937 sort_by_digest = sort_by_digest_4_4;
7938 opti_type = OPTI_TYPE_ZERO_BYTE
7939 | OPTI_TYPE_PRECOMPUTE_INIT
7940 | OPTI_TYPE_PRECOMPUTE_MERKLE
7941 | OPTI_TYPE_EARLY_SKIP;
7942 dgst_pos0 = 0;
7943 dgst_pos1 = 3;
7944 dgst_pos2 = 2;
7945 dgst_pos3 = 1;
7946 break;
7947
7948 case 2612: hash_type = HASH_TYPE_MD5;
7949 salt_type = SALT_TYPE_EMBEDDED;
7950 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7951 opts_type = OPTS_TYPE_PT_GENERATE_LE
7952 | OPTS_TYPE_PT_ADD80
7953 | OPTS_TYPE_PT_ADDBITS14
7954 | OPTS_TYPE_ST_ADD80
7955 | OPTS_TYPE_ST_HEX;
7956 kern_type = KERN_TYPE_MD55_PWSLT1;
7957 dgst_size = DGST_SIZE_4_4;
7958 parse_func = phps_parse_hash;
7959 sort_by_digest = sort_by_digest_4_4;
7960 opti_type = OPTI_TYPE_ZERO_BYTE
7961 | OPTI_TYPE_PRECOMPUTE_INIT
7962 | OPTI_TYPE_PRECOMPUTE_MERKLE
7963 | OPTI_TYPE_EARLY_SKIP;
7964 dgst_pos0 = 0;
7965 dgst_pos1 = 3;
7966 dgst_pos2 = 2;
7967 dgst_pos3 = 1;
7968 break;
7969
7970 case 2711: hash_type = HASH_TYPE_MD5;
7971 salt_type = SALT_TYPE_INTERN;
7972 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7973 opts_type = OPTS_TYPE_PT_GENERATE_LE
7974 | OPTS_TYPE_PT_ADD80
7975 | OPTS_TYPE_PT_ADDBITS14
7976 | OPTS_TYPE_ST_ADD80;
7977 kern_type = KERN_TYPE_MD55_PWSLT2;
7978 dgst_size = DGST_SIZE_4_4;
7979 parse_func = vb30_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 2811: hash_type = HASH_TYPE_MD5;
7991 salt_type = SALT_TYPE_INTERN;
7992 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7993 opts_type = OPTS_TYPE_PT_GENERATE_LE
7994 | OPTS_TYPE_PT_ADD80
7995 | OPTS_TYPE_PT_ADDBITS14;
7996 kern_type = KERN_TYPE_MD55_SLTPW;
7997 dgst_size = DGST_SIZE_4_4;
7998 parse_func = ipb2_parse_hash;
7999 sort_by_digest = sort_by_digest_4_4;
8000 opti_type = OPTI_TYPE_ZERO_BYTE
8001 | OPTI_TYPE_PRECOMPUTE_INIT
8002 | OPTI_TYPE_EARLY_SKIP;
8003 dgst_pos0 = 0;
8004 dgst_pos1 = 3;
8005 dgst_pos2 = 2;
8006 dgst_pos3 = 1;
8007 break;
8008
8009 case 3000: hash_type = HASH_TYPE_LM;
8010 salt_type = SALT_TYPE_NONE;
8011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8012 opts_type = OPTS_TYPE_PT_GENERATE_LE
8013 | OPTS_TYPE_PT_UPPER
8014 | OPTS_TYPE_PT_BITSLICE;
8015 kern_type = KERN_TYPE_LM;
8016 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8017 parse_func = lm_parse_hash;
8018 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8019 opti_type = OPTI_TYPE_ZERO_BYTE
8020 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8021 dgst_pos0 = 0;
8022 dgst_pos1 = 1;
8023 dgst_pos2 = 2;
8024 dgst_pos3 = 3;
8025 break;
8026
8027 case 3100: hash_type = HASH_TYPE_ORACLEH;
8028 salt_type = SALT_TYPE_INTERN;
8029 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8030 opts_type = OPTS_TYPE_PT_GENERATE_LE
8031 | OPTS_TYPE_PT_UPPER
8032 | OPTS_TYPE_ST_UPPER;
8033 kern_type = KERN_TYPE_ORACLEH;
8034 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8035 parse_func = oracleh_parse_hash;
8036 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8037 opti_type = OPTI_TYPE_ZERO_BYTE;
8038 dgst_pos0 = 0;
8039 dgst_pos1 = 1;
8040 dgst_pos2 = 2;
8041 dgst_pos3 = 3;
8042 break;
8043
8044 case 3200: hash_type = HASH_TYPE_BCRYPT;
8045 salt_type = SALT_TYPE_EMBEDDED;
8046 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8047 opts_type = OPTS_TYPE_PT_GENERATE_LE
8048 | OPTS_TYPE_ST_GENERATE_LE;
8049 kern_type = KERN_TYPE_BCRYPT;
8050 dgst_size = DGST_SIZE_4_6;
8051 parse_func = bcrypt_parse_hash;
8052 sort_by_digest = sort_by_digest_4_6;
8053 opti_type = OPTI_TYPE_ZERO_BYTE;
8054 dgst_pos0 = 0;
8055 dgst_pos1 = 1;
8056 dgst_pos2 = 2;
8057 dgst_pos3 = 3;
8058 break;
8059
8060 case 3710: hash_type = HASH_TYPE_MD5;
8061 salt_type = SALT_TYPE_INTERN;
8062 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8063 opts_type = OPTS_TYPE_PT_GENERATE_LE
8064 | OPTS_TYPE_PT_ADD80
8065 | OPTS_TYPE_PT_ADDBITS14;
8066 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8067 dgst_size = DGST_SIZE_4_4;
8068 parse_func = md5s_parse_hash;
8069 sort_by_digest = sort_by_digest_4_4;
8070 opti_type = OPTI_TYPE_ZERO_BYTE
8071 | OPTI_TYPE_PRECOMPUTE_INIT
8072 | OPTI_TYPE_PRECOMPUTE_MERKLE
8073 | OPTI_TYPE_EARLY_SKIP;
8074 dgst_pos0 = 0;
8075 dgst_pos1 = 3;
8076 dgst_pos2 = 2;
8077 dgst_pos3 = 1;
8078 break;
8079
8080 case 3711: hash_type = HASH_TYPE_MD5;
8081 salt_type = SALT_TYPE_EMBEDDED;
8082 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8083 opts_type = OPTS_TYPE_PT_GENERATE_LE
8084 | OPTS_TYPE_PT_ADD80
8085 | OPTS_TYPE_PT_ADDBITS14;
8086 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8087 dgst_size = DGST_SIZE_4_4;
8088 parse_func = mediawiki_b_parse_hash;
8089 sort_by_digest = sort_by_digest_4_4;
8090 opti_type = OPTI_TYPE_ZERO_BYTE
8091 | OPTI_TYPE_PRECOMPUTE_INIT
8092 | OPTI_TYPE_PRECOMPUTE_MERKLE
8093 | OPTI_TYPE_EARLY_SKIP;
8094 dgst_pos0 = 0;
8095 dgst_pos1 = 3;
8096 dgst_pos2 = 2;
8097 dgst_pos3 = 1;
8098 break;
8099
8100 case 3800: hash_type = HASH_TYPE_MD5;
8101 salt_type = SALT_TYPE_INTERN;
8102 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8103 opts_type = OPTS_TYPE_PT_GENERATE_LE
8104 | OPTS_TYPE_ST_ADDBITS14;
8105 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8106 dgst_size = DGST_SIZE_4_4;
8107 parse_func = md5s_parse_hash;
8108 sort_by_digest = sort_by_digest_4_4;
8109 opti_type = OPTI_TYPE_ZERO_BYTE
8110 | OPTI_TYPE_PRECOMPUTE_INIT
8111 | OPTI_TYPE_PRECOMPUTE_MERKLE
8112 | OPTI_TYPE_EARLY_SKIP
8113 | OPTI_TYPE_NOT_ITERATED
8114 | OPTI_TYPE_RAW_HASH;
8115 dgst_pos0 = 0;
8116 dgst_pos1 = 3;
8117 dgst_pos2 = 2;
8118 dgst_pos3 = 1;
8119 break;
8120
8121 case 4300: hash_type = HASH_TYPE_MD5;
8122 salt_type = SALT_TYPE_VIRTUAL;
8123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8124 opts_type = OPTS_TYPE_PT_GENERATE_LE
8125 | OPTS_TYPE_PT_ADD80
8126 | OPTS_TYPE_PT_ADDBITS14
8127 | OPTS_TYPE_ST_ADD80;
8128 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8129 dgst_size = DGST_SIZE_4_4;
8130 parse_func = md5md5_parse_hash;
8131 sort_by_digest = sort_by_digest_4_4;
8132 opti_type = OPTI_TYPE_ZERO_BYTE
8133 | OPTI_TYPE_PRECOMPUTE_INIT
8134 | OPTI_TYPE_PRECOMPUTE_MERKLE
8135 | OPTI_TYPE_EARLY_SKIP;
8136 dgst_pos0 = 0;
8137 dgst_pos1 = 3;
8138 dgst_pos2 = 2;
8139 dgst_pos3 = 1;
8140 break;
8141
8142
8143 case 4400: hash_type = HASH_TYPE_MD5;
8144 salt_type = SALT_TYPE_NONE;
8145 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8146 opts_type = OPTS_TYPE_PT_GENERATE_BE
8147 | OPTS_TYPE_PT_ADD80
8148 | OPTS_TYPE_PT_ADDBITS15;
8149 kern_type = KERN_TYPE_MD5_SHA1;
8150 dgst_size = DGST_SIZE_4_4;
8151 parse_func = md5_parse_hash;
8152 sort_by_digest = sort_by_digest_4_4;
8153 opti_type = OPTI_TYPE_ZERO_BYTE
8154 | OPTI_TYPE_PRECOMPUTE_INIT
8155 | OPTI_TYPE_PRECOMPUTE_MERKLE
8156 | OPTI_TYPE_EARLY_SKIP
8157 | OPTI_TYPE_NOT_ITERATED
8158 | OPTI_TYPE_NOT_SALTED
8159 | OPTI_TYPE_RAW_HASH;
8160 dgst_pos0 = 0;
8161 dgst_pos1 = 3;
8162 dgst_pos2 = 2;
8163 dgst_pos3 = 1;
8164 break;
8165
8166 case 4500: hash_type = HASH_TYPE_SHA1;
8167 salt_type = SALT_TYPE_NONE;
8168 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8169 opts_type = OPTS_TYPE_PT_GENERATE_BE
8170 | OPTS_TYPE_PT_ADD80
8171 | OPTS_TYPE_PT_ADDBITS15;
8172 kern_type = KERN_TYPE_SHA11;
8173 dgst_size = DGST_SIZE_4_5;
8174 parse_func = sha1_parse_hash;
8175 sort_by_digest = sort_by_digest_4_5;
8176 opti_type = OPTI_TYPE_ZERO_BYTE
8177 | OPTI_TYPE_PRECOMPUTE_INIT
8178 | OPTI_TYPE_PRECOMPUTE_MERKLE
8179 | OPTI_TYPE_EARLY_SKIP
8180 | OPTI_TYPE_NOT_SALTED;
8181 dgst_pos0 = 3;
8182 dgst_pos1 = 4;
8183 dgst_pos2 = 2;
8184 dgst_pos3 = 1;
8185 break;
8186
8187 case 4700: hash_type = HASH_TYPE_SHA1;
8188 salt_type = SALT_TYPE_NONE;
8189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8190 opts_type = OPTS_TYPE_PT_GENERATE_LE
8191 | OPTS_TYPE_PT_ADD80
8192 | OPTS_TYPE_PT_ADDBITS14;
8193 kern_type = KERN_TYPE_SHA1_MD5;
8194 dgst_size = DGST_SIZE_4_5;
8195 parse_func = sha1_parse_hash;
8196 sort_by_digest = sort_by_digest_4_5;
8197 opti_type = OPTI_TYPE_ZERO_BYTE
8198 | OPTI_TYPE_PRECOMPUTE_INIT
8199 | OPTI_TYPE_PRECOMPUTE_MERKLE
8200 | OPTI_TYPE_EARLY_SKIP
8201 | OPTI_TYPE_NOT_ITERATED
8202 | OPTI_TYPE_NOT_SALTED
8203 | OPTI_TYPE_RAW_HASH;
8204 dgst_pos0 = 3;
8205 dgst_pos1 = 4;
8206 dgst_pos2 = 2;
8207 dgst_pos3 = 1;
8208 break;
8209
8210 case 4800: hash_type = HASH_TYPE_MD5;
8211 salt_type = SALT_TYPE_EMBEDDED;
8212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8213 opts_type = OPTS_TYPE_PT_GENERATE_LE
8214 | OPTS_TYPE_PT_ADDBITS14;
8215 kern_type = KERN_TYPE_MD5_CHAP;
8216 dgst_size = DGST_SIZE_4_4;
8217 parse_func = chap_parse_hash;
8218 sort_by_digest = sort_by_digest_4_4;
8219 opti_type = OPTI_TYPE_ZERO_BYTE
8220 | OPTI_TYPE_PRECOMPUTE_INIT
8221 | OPTI_TYPE_PRECOMPUTE_MERKLE
8222 | OPTI_TYPE_MEET_IN_MIDDLE
8223 | OPTI_TYPE_EARLY_SKIP
8224 | OPTI_TYPE_NOT_ITERATED
8225 | OPTI_TYPE_RAW_HASH;
8226 dgst_pos0 = 0;
8227 dgst_pos1 = 3;
8228 dgst_pos2 = 2;
8229 dgst_pos3 = 1;
8230 break;
8231
8232 case 4900: hash_type = HASH_TYPE_SHA1;
8233 salt_type = SALT_TYPE_INTERN;
8234 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8235 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8236 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8237 dgst_size = DGST_SIZE_4_5;
8238 parse_func = sha1s_parse_hash;
8239 sort_by_digest = sort_by_digest_4_5;
8240 opti_type = OPTI_TYPE_ZERO_BYTE
8241 | OPTI_TYPE_PRECOMPUTE_INIT
8242 | OPTI_TYPE_PRECOMPUTE_MERKLE
8243 | OPTI_TYPE_EARLY_SKIP;
8244 dgst_pos0 = 3;
8245 dgst_pos1 = 4;
8246 dgst_pos2 = 2;
8247 dgst_pos3 = 1;
8248 break;
8249
8250 case 5000: hash_type = HASH_TYPE_KECCAK;
8251 salt_type = SALT_TYPE_EMBEDDED;
8252 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8253 opts_type = OPTS_TYPE_PT_GENERATE_LE
8254 | OPTS_TYPE_PT_ADD01;
8255 kern_type = KERN_TYPE_KECCAK;
8256 dgst_size = DGST_SIZE_8_25;
8257 parse_func = keccak_parse_hash;
8258 sort_by_digest = sort_by_digest_8_25;
8259 opti_type = OPTI_TYPE_ZERO_BYTE
8260 | OPTI_TYPE_RAW_HASH;
8261 dgst_pos0 = 2;
8262 dgst_pos1 = 3;
8263 dgst_pos2 = 4;
8264 dgst_pos3 = 5;
8265 break;
8266
8267 case 5100: hash_type = HASH_TYPE_MD5H;
8268 salt_type = SALT_TYPE_NONE;
8269 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8270 opts_type = OPTS_TYPE_PT_GENERATE_LE
8271 | OPTS_TYPE_PT_ADD80
8272 | OPTS_TYPE_PT_ADDBITS14;
8273 kern_type = KERN_TYPE_MD5H;
8274 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8275 parse_func = md5half_parse_hash;
8276 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8277 opti_type = OPTI_TYPE_ZERO_BYTE
8278 | OPTI_TYPE_RAW_HASH;
8279 dgst_pos0 = 0;
8280 dgst_pos1 = 1;
8281 dgst_pos2 = 2;
8282 dgst_pos3 = 3;
8283 break;
8284
8285 case 5200: hash_type = HASH_TYPE_SHA256;
8286 salt_type = SALT_TYPE_EMBEDDED;
8287 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8288 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8289 kern_type = KERN_TYPE_PSAFE3;
8290 dgst_size = DGST_SIZE_4_8;
8291 parse_func = psafe3_parse_hash;
8292 sort_by_digest = sort_by_digest_4_8;
8293 opti_type = OPTI_TYPE_ZERO_BYTE;
8294 dgst_pos0 = 0;
8295 dgst_pos1 = 1;
8296 dgst_pos2 = 2;
8297 dgst_pos3 = 3;
8298 break;
8299
8300 case 5300: hash_type = HASH_TYPE_MD5;
8301 salt_type = SALT_TYPE_EMBEDDED;
8302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8303 opts_type = OPTS_TYPE_PT_GENERATE_LE
8304 | OPTS_TYPE_ST_ADD80;
8305 kern_type = KERN_TYPE_IKEPSK_MD5;
8306 dgst_size = DGST_SIZE_4_4;
8307 parse_func = ikepsk_md5_parse_hash;
8308 sort_by_digest = sort_by_digest_4_4;
8309 opti_type = OPTI_TYPE_ZERO_BYTE;
8310 dgst_pos0 = 0;
8311 dgst_pos1 = 3;
8312 dgst_pos2 = 2;
8313 dgst_pos3 = 1;
8314 break;
8315
8316 case 5400: hash_type = HASH_TYPE_SHA1;
8317 salt_type = SALT_TYPE_EMBEDDED;
8318 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8319 opts_type = OPTS_TYPE_PT_GENERATE_BE
8320 | OPTS_TYPE_ST_ADD80;
8321 kern_type = KERN_TYPE_IKEPSK_SHA1;
8322 dgst_size = DGST_SIZE_4_5;
8323 parse_func = ikepsk_sha1_parse_hash;
8324 sort_by_digest = sort_by_digest_4_5;
8325 opti_type = OPTI_TYPE_ZERO_BYTE;
8326 dgst_pos0 = 3;
8327 dgst_pos1 = 4;
8328 dgst_pos2 = 2;
8329 dgst_pos3 = 1;
8330 break;
8331
8332 case 5500: hash_type = HASH_TYPE_NETNTLM;
8333 salt_type = SALT_TYPE_EMBEDDED;
8334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8335 opts_type = OPTS_TYPE_PT_GENERATE_LE
8336 | OPTS_TYPE_PT_ADD80
8337 | OPTS_TYPE_PT_ADDBITS14
8338 | OPTS_TYPE_PT_UNICODE
8339 | OPTS_TYPE_ST_HEX;
8340 kern_type = KERN_TYPE_NETNTLMv1;
8341 dgst_size = DGST_SIZE_4_4;
8342 parse_func = netntlmv1_parse_hash;
8343 sort_by_digest = sort_by_digest_4_4;
8344 opti_type = OPTI_TYPE_ZERO_BYTE
8345 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8346 dgst_pos0 = 0;
8347 dgst_pos1 = 1;
8348 dgst_pos2 = 2;
8349 dgst_pos3 = 3;
8350 break;
8351
8352 case 5600: hash_type = HASH_TYPE_MD5;
8353 salt_type = SALT_TYPE_EMBEDDED;
8354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8355 opts_type = OPTS_TYPE_PT_GENERATE_LE
8356 | OPTS_TYPE_PT_ADD80
8357 | OPTS_TYPE_PT_ADDBITS14
8358 | OPTS_TYPE_PT_UNICODE;
8359 kern_type = KERN_TYPE_NETNTLMv2;
8360 dgst_size = DGST_SIZE_4_4;
8361 parse_func = netntlmv2_parse_hash;
8362 sort_by_digest = sort_by_digest_4_4;
8363 opti_type = OPTI_TYPE_ZERO_BYTE;
8364 dgst_pos0 = 0;
8365 dgst_pos1 = 3;
8366 dgst_pos2 = 2;
8367 dgst_pos3 = 1;
8368 break;
8369
8370 case 5700: hash_type = HASH_TYPE_SHA256;
8371 salt_type = SALT_TYPE_NONE;
8372 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8373 opts_type = OPTS_TYPE_PT_GENERATE_BE
8374 | OPTS_TYPE_PT_ADD80
8375 | OPTS_TYPE_PT_ADDBITS15;
8376 kern_type = KERN_TYPE_SHA256;
8377 dgst_size = DGST_SIZE_4_8;
8378 parse_func = cisco4_parse_hash;
8379 sort_by_digest = sort_by_digest_4_8;
8380 opti_type = OPTI_TYPE_ZERO_BYTE
8381 | OPTI_TYPE_PRECOMPUTE_INIT
8382 | OPTI_TYPE_PRECOMPUTE_MERKLE
8383 | OPTI_TYPE_EARLY_SKIP
8384 | OPTI_TYPE_NOT_ITERATED
8385 | OPTI_TYPE_NOT_SALTED
8386 | OPTI_TYPE_RAW_HASH;
8387 dgst_pos0 = 3;
8388 dgst_pos1 = 7;
8389 dgst_pos2 = 2;
8390 dgst_pos3 = 6;
8391 break;
8392
8393 case 5800: hash_type = HASH_TYPE_SHA1;
8394 salt_type = SALT_TYPE_INTERN;
8395 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8396 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8397 | OPTS_TYPE_ST_ADD80;
8398 kern_type = KERN_TYPE_ANDROIDPIN;
8399 dgst_size = DGST_SIZE_4_5;
8400 parse_func = androidpin_parse_hash;
8401 sort_by_digest = sort_by_digest_4_5;
8402 opti_type = OPTI_TYPE_ZERO_BYTE;
8403 dgst_pos0 = 0;
8404 dgst_pos1 = 1;
8405 dgst_pos2 = 2;
8406 dgst_pos3 = 3;
8407 break;
8408
8409 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8410 salt_type = SALT_TYPE_NONE;
8411 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8412 opts_type = OPTS_TYPE_PT_GENERATE_LE
8413 | OPTS_TYPE_PT_ADD80;
8414 kern_type = KERN_TYPE_RIPEMD160;
8415 dgst_size = DGST_SIZE_4_5;
8416 parse_func = ripemd160_parse_hash;
8417 sort_by_digest = sort_by_digest_4_5;
8418 opti_type = OPTI_TYPE_ZERO_BYTE;
8419 dgst_pos0 = 0;
8420 dgst_pos1 = 1;
8421 dgst_pos2 = 2;
8422 dgst_pos3 = 3;
8423 break;
8424
8425 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8426 salt_type = SALT_TYPE_NONE;
8427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8428 opts_type = OPTS_TYPE_PT_GENERATE_BE
8429 | OPTS_TYPE_PT_ADD80;
8430 kern_type = KERN_TYPE_WHIRLPOOL;
8431 dgst_size = DGST_SIZE_4_16;
8432 parse_func = whirlpool_parse_hash;
8433 sort_by_digest = sort_by_digest_4_16;
8434 opti_type = OPTI_TYPE_ZERO_BYTE;
8435 dgst_pos0 = 0;
8436 dgst_pos1 = 1;
8437 dgst_pos2 = 2;
8438 dgst_pos3 = 3;
8439 break;
8440
8441 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8442 salt_type = SALT_TYPE_EMBEDDED;
8443 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8444 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8445 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8446 dgst_size = DGST_SIZE_4_5;
8447 parse_func = truecrypt_parse_hash_2k;
8448 sort_by_digest = sort_by_digest_4_5;
8449 opti_type = OPTI_TYPE_ZERO_BYTE;
8450 dgst_pos0 = 0;
8451 dgst_pos1 = 1;
8452 dgst_pos2 = 2;
8453 dgst_pos3 = 3;
8454 break;
8455
8456 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8457 salt_type = SALT_TYPE_EMBEDDED;
8458 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8459 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8460 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8461 dgst_size = DGST_SIZE_4_5;
8462 parse_func = truecrypt_parse_hash_2k;
8463 sort_by_digest = sort_by_digest_4_5;
8464 opti_type = OPTI_TYPE_ZERO_BYTE;
8465 dgst_pos0 = 0;
8466 dgst_pos1 = 1;
8467 dgst_pos2 = 2;
8468 dgst_pos3 = 3;
8469 break;
8470
8471 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8472 salt_type = SALT_TYPE_EMBEDDED;
8473 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8474 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8475 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8476 dgst_size = DGST_SIZE_4_5;
8477 parse_func = truecrypt_parse_hash_2k;
8478 sort_by_digest = sort_by_digest_4_5;
8479 opti_type = OPTI_TYPE_ZERO_BYTE;
8480 dgst_pos0 = 0;
8481 dgst_pos1 = 1;
8482 dgst_pos2 = 2;
8483 dgst_pos3 = 3;
8484 break;
8485
8486 case 6221: hash_type = HASH_TYPE_SHA512;
8487 salt_type = SALT_TYPE_EMBEDDED;
8488 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8489 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8490 kern_type = KERN_TYPE_TCSHA512_XTS512;
8491 dgst_size = DGST_SIZE_8_8;
8492 parse_func = truecrypt_parse_hash_1k;
8493 sort_by_digest = sort_by_digest_8_8;
8494 opti_type = OPTI_TYPE_ZERO_BYTE;
8495 dgst_pos0 = 0;
8496 dgst_pos1 = 1;
8497 dgst_pos2 = 2;
8498 dgst_pos3 = 3;
8499 break;
8500
8501 case 6222: hash_type = HASH_TYPE_SHA512;
8502 salt_type = SALT_TYPE_EMBEDDED;
8503 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8504 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8505 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8506 dgst_size = DGST_SIZE_8_8;
8507 parse_func = truecrypt_parse_hash_1k;
8508 sort_by_digest = sort_by_digest_8_8;
8509 opti_type = OPTI_TYPE_ZERO_BYTE;
8510 dgst_pos0 = 0;
8511 dgst_pos1 = 1;
8512 dgst_pos2 = 2;
8513 dgst_pos3 = 3;
8514 break;
8515
8516 case 6223: hash_type = HASH_TYPE_SHA512;
8517 salt_type = SALT_TYPE_EMBEDDED;
8518 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8519 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8520 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8521 dgst_size = DGST_SIZE_8_8;
8522 parse_func = truecrypt_parse_hash_1k;
8523 sort_by_digest = sort_by_digest_8_8;
8524 opti_type = OPTI_TYPE_ZERO_BYTE;
8525 dgst_pos0 = 0;
8526 dgst_pos1 = 1;
8527 dgst_pos2 = 2;
8528 dgst_pos3 = 3;
8529 break;
8530
8531 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8532 salt_type = SALT_TYPE_EMBEDDED;
8533 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8534 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8535 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8536 dgst_size = DGST_SIZE_4_8;
8537 parse_func = truecrypt_parse_hash_1k;
8538 sort_by_digest = sort_by_digest_4_8;
8539 opti_type = OPTI_TYPE_ZERO_BYTE;
8540 dgst_pos0 = 0;
8541 dgst_pos1 = 1;
8542 dgst_pos2 = 2;
8543 dgst_pos3 = 3;
8544 break;
8545
8546 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8547 salt_type = SALT_TYPE_EMBEDDED;
8548 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8549 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8550 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8551 dgst_size = DGST_SIZE_4_8;
8552 parse_func = truecrypt_parse_hash_1k;
8553 sort_by_digest = sort_by_digest_4_8;
8554 opti_type = OPTI_TYPE_ZERO_BYTE;
8555 dgst_pos0 = 0;
8556 dgst_pos1 = 1;
8557 dgst_pos2 = 2;
8558 dgst_pos3 = 3;
8559 break;
8560
8561 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8562 salt_type = SALT_TYPE_EMBEDDED;
8563 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8564 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8565 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8566 dgst_size = DGST_SIZE_4_8;
8567 parse_func = truecrypt_parse_hash_1k;
8568 sort_by_digest = sort_by_digest_4_8;
8569 opti_type = OPTI_TYPE_ZERO_BYTE;
8570 dgst_pos0 = 0;
8571 dgst_pos1 = 1;
8572 dgst_pos2 = 2;
8573 dgst_pos3 = 3;
8574 break;
8575
8576 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8577 salt_type = SALT_TYPE_EMBEDDED;
8578 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8579 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8580 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8581 dgst_size = DGST_SIZE_4_5;
8582 parse_func = truecrypt_parse_hash_1k;
8583 sort_by_digest = sort_by_digest_4_5;
8584 opti_type = OPTI_TYPE_ZERO_BYTE;
8585 dgst_pos0 = 0;
8586 dgst_pos1 = 1;
8587 dgst_pos2 = 2;
8588 dgst_pos3 = 3;
8589 break;
8590
8591 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8592 salt_type = SALT_TYPE_EMBEDDED;
8593 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8594 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8595 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8596 dgst_size = DGST_SIZE_4_5;
8597 parse_func = truecrypt_parse_hash_1k;
8598 sort_by_digest = sort_by_digest_4_5;
8599 opti_type = OPTI_TYPE_ZERO_BYTE;
8600 dgst_pos0 = 0;
8601 dgst_pos1 = 1;
8602 dgst_pos2 = 2;
8603 dgst_pos3 = 3;
8604 break;
8605
8606 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8607 salt_type = SALT_TYPE_EMBEDDED;
8608 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8609 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8610 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8611 dgst_size = DGST_SIZE_4_5;
8612 parse_func = truecrypt_parse_hash_1k;
8613 sort_by_digest = sort_by_digest_4_5;
8614 opti_type = OPTI_TYPE_ZERO_BYTE;
8615 dgst_pos0 = 0;
8616 dgst_pos1 = 1;
8617 dgst_pos2 = 2;
8618 dgst_pos3 = 3;
8619 break;
8620
8621 case 6300: hash_type = HASH_TYPE_MD5;
8622 salt_type = SALT_TYPE_EMBEDDED;
8623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8624 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8625 kern_type = KERN_TYPE_MD5AIX;
8626 dgst_size = DGST_SIZE_4_4;
8627 parse_func = md5aix_parse_hash;
8628 sort_by_digest = sort_by_digest_4_4;
8629 opti_type = OPTI_TYPE_ZERO_BYTE;
8630 dgst_pos0 = 0;
8631 dgst_pos1 = 1;
8632 dgst_pos2 = 2;
8633 dgst_pos3 = 3;
8634 break;
8635
8636 case 6400: hash_type = HASH_TYPE_SHA256;
8637 salt_type = SALT_TYPE_EMBEDDED;
8638 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8639 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8640 kern_type = KERN_TYPE_SHA256AIX;
8641 dgst_size = DGST_SIZE_4_8;
8642 parse_func = sha256aix_parse_hash;
8643 sort_by_digest = sort_by_digest_4_8;
8644 opti_type = OPTI_TYPE_ZERO_BYTE;
8645 dgst_pos0 = 0;
8646 dgst_pos1 = 1;
8647 dgst_pos2 = 2;
8648 dgst_pos3 = 3;
8649 break;
8650
8651 case 6500: hash_type = HASH_TYPE_SHA512;
8652 salt_type = SALT_TYPE_EMBEDDED;
8653 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8654 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8655 kern_type = KERN_TYPE_SHA512AIX;
8656 dgst_size = DGST_SIZE_8_8;
8657 parse_func = sha512aix_parse_hash;
8658 sort_by_digest = sort_by_digest_8_8;
8659 opti_type = OPTI_TYPE_ZERO_BYTE;
8660 dgst_pos0 = 0;
8661 dgst_pos1 = 1;
8662 dgst_pos2 = 2;
8663 dgst_pos3 = 3;
8664 break;
8665
8666 case 6600: hash_type = HASH_TYPE_AES;
8667 salt_type = SALT_TYPE_EMBEDDED;
8668 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8669 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8670 kern_type = KERN_TYPE_AGILEKEY;
8671 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8672 parse_func = agilekey_parse_hash;
8673 sort_by_digest = sort_by_digest_4_5;
8674 opti_type = OPTI_TYPE_ZERO_BYTE;
8675 dgst_pos0 = 0;
8676 dgst_pos1 = 1;
8677 dgst_pos2 = 2;
8678 dgst_pos3 = 3;
8679 break;
8680
8681 case 6700: hash_type = HASH_TYPE_SHA1;
8682 salt_type = SALT_TYPE_EMBEDDED;
8683 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8684 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8685 kern_type = KERN_TYPE_SHA1AIX;
8686 dgst_size = DGST_SIZE_4_5;
8687 parse_func = sha1aix_parse_hash;
8688 sort_by_digest = sort_by_digest_4_5;
8689 opti_type = OPTI_TYPE_ZERO_BYTE;
8690 dgst_pos0 = 0;
8691 dgst_pos1 = 1;
8692 dgst_pos2 = 2;
8693 dgst_pos3 = 3;
8694 break;
8695
8696 case 6800: hash_type = HASH_TYPE_AES;
8697 salt_type = SALT_TYPE_EMBEDDED;
8698 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8699 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8700 kern_type = KERN_TYPE_LASTPASS;
8701 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8702 parse_func = lastpass_parse_hash;
8703 sort_by_digest = sort_by_digest_4_8;
8704 opti_type = OPTI_TYPE_ZERO_BYTE;
8705 dgst_pos0 = 0;
8706 dgst_pos1 = 1;
8707 dgst_pos2 = 2;
8708 dgst_pos3 = 3;
8709 break;
8710
8711 case 6900: hash_type = HASH_TYPE_GOST;
8712 salt_type = SALT_TYPE_NONE;
8713 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8714 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8715 kern_type = KERN_TYPE_GOST;
8716 dgst_size = DGST_SIZE_4_8;
8717 parse_func = gost_parse_hash;
8718 sort_by_digest = sort_by_digest_4_8;
8719 opti_type = OPTI_TYPE_ZERO_BYTE;
8720 dgst_pos0 = 0;
8721 dgst_pos1 = 1;
8722 dgst_pos2 = 2;
8723 dgst_pos3 = 3;
8724 break;
8725
8726 case 7100: hash_type = HASH_TYPE_SHA512;
8727 salt_type = SALT_TYPE_EMBEDDED;
8728 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8729 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8730 kern_type = KERN_TYPE_PBKDF2_SHA512;
8731 dgst_size = DGST_SIZE_8_16;
8732 parse_func = sha512osx_parse_hash;
8733 sort_by_digest = sort_by_digest_8_16;
8734 opti_type = OPTI_TYPE_ZERO_BYTE;
8735 dgst_pos0 = 0;
8736 dgst_pos1 = 1;
8737 dgst_pos2 = 2;
8738 dgst_pos3 = 3;
8739 break;
8740
8741 case 7200: hash_type = HASH_TYPE_SHA512;
8742 salt_type = SALT_TYPE_EMBEDDED;
8743 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8744 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8745 kern_type = KERN_TYPE_PBKDF2_SHA512;
8746 dgst_size = DGST_SIZE_8_16;
8747 parse_func = sha512grub_parse_hash;
8748 sort_by_digest = sort_by_digest_8_16;
8749 opti_type = OPTI_TYPE_ZERO_BYTE;
8750 dgst_pos0 = 0;
8751 dgst_pos1 = 1;
8752 dgst_pos2 = 2;
8753 dgst_pos3 = 3;
8754 break;
8755
8756 case 7300: hash_type = HASH_TYPE_SHA1;
8757 salt_type = SALT_TYPE_EMBEDDED;
8758 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8759 opts_type = OPTS_TYPE_PT_GENERATE_BE
8760 | OPTS_TYPE_ST_ADD80
8761 | OPTS_TYPE_ST_ADDBITS15;
8762 kern_type = KERN_TYPE_RAKP;
8763 dgst_size = DGST_SIZE_4_5;
8764 parse_func = rakp_parse_hash;
8765 sort_by_digest = sort_by_digest_4_5;
8766 opti_type = OPTI_TYPE_ZERO_BYTE
8767 | OPTI_TYPE_NOT_ITERATED;
8768 dgst_pos0 = 3;
8769 dgst_pos1 = 4;
8770 dgst_pos2 = 2;
8771 dgst_pos3 = 1;
8772 break;
8773
8774 case 7400: hash_type = HASH_TYPE_SHA256;
8775 salt_type = SALT_TYPE_EMBEDDED;
8776 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8777 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8778 kern_type = KERN_TYPE_SHA256CRYPT;
8779 dgst_size = DGST_SIZE_4_8;
8780 parse_func = sha256crypt_parse_hash;
8781 sort_by_digest = sort_by_digest_4_8;
8782 opti_type = OPTI_TYPE_ZERO_BYTE;
8783 dgst_pos0 = 0;
8784 dgst_pos1 = 1;
8785 dgst_pos2 = 2;
8786 dgst_pos3 = 3;
8787 break;
8788
8789 case 7500: hash_type = HASH_TYPE_KRB5PA;
8790 salt_type = SALT_TYPE_EMBEDDED;
8791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8792 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8793 kern_type = KERN_TYPE_KRB5PA;
8794 dgst_size = DGST_SIZE_4_4;
8795 parse_func = krb5pa_parse_hash;
8796 sort_by_digest = sort_by_digest_4_4;
8797 opti_type = OPTI_TYPE_ZERO_BYTE
8798 | OPTI_TYPE_NOT_ITERATED;
8799 dgst_pos0 = 3;
8800 dgst_pos1 = 7;
8801 dgst_pos2 = 2;
8802 dgst_pos3 = 6;
8803 break;
8804
8805 case 7600: hash_type = HASH_TYPE_SHA1;
8806 salt_type = SALT_TYPE_INTERN;
8807 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8808 opts_type = OPTS_TYPE_PT_GENERATE_BE
8809 | OPTS_TYPE_PT_ADD80
8810 | OPTS_TYPE_PT_ADDBITS15;
8811 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8812 dgst_size = DGST_SIZE_4_5;
8813 parse_func = redmine_parse_hash;
8814 sort_by_digest = sort_by_digest_4_5;
8815 opti_type = OPTI_TYPE_ZERO_BYTE
8816 | OPTI_TYPE_PRECOMPUTE_INIT
8817 | OPTI_TYPE_EARLY_SKIP
8818 | OPTI_TYPE_NOT_ITERATED
8819 | OPTI_TYPE_PREPENDED_SALT;
8820 dgst_pos0 = 3;
8821 dgst_pos1 = 4;
8822 dgst_pos2 = 2;
8823 dgst_pos3 = 1;
8824 break;
8825
8826 case 7700: hash_type = HASH_TYPE_SAPB;
8827 salt_type = SALT_TYPE_EMBEDDED;
8828 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8829 opts_type = OPTS_TYPE_PT_GENERATE_LE
8830 | OPTS_TYPE_PT_UPPER
8831 | OPTS_TYPE_ST_UPPER;
8832 kern_type = KERN_TYPE_SAPB;
8833 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8834 parse_func = sapb_parse_hash;
8835 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8836 opti_type = OPTI_TYPE_ZERO_BYTE
8837 | OPTI_TYPE_PRECOMPUTE_INIT
8838 | OPTI_TYPE_NOT_ITERATED;
8839 dgst_pos0 = 0;
8840 dgst_pos1 = 1;
8841 dgst_pos2 = 2;
8842 dgst_pos3 = 3;
8843 break;
8844
8845 case 7800: hash_type = HASH_TYPE_SAPG;
8846 salt_type = SALT_TYPE_EMBEDDED;
8847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8848 opts_type = OPTS_TYPE_PT_GENERATE_BE
8849 | OPTS_TYPE_ST_ADD80
8850 | OPTS_TYPE_ST_UPPER;
8851 kern_type = KERN_TYPE_SAPG;
8852 dgst_size = DGST_SIZE_4_5;
8853 parse_func = sapg_parse_hash;
8854 sort_by_digest = sort_by_digest_4_5;
8855 opti_type = OPTI_TYPE_ZERO_BYTE
8856 | OPTI_TYPE_PRECOMPUTE_INIT
8857 | OPTI_TYPE_NOT_ITERATED;
8858 dgst_pos0 = 3;
8859 dgst_pos1 = 4;
8860 dgst_pos2 = 2;
8861 dgst_pos3 = 1;
8862 break;
8863
8864 case 7900: hash_type = HASH_TYPE_SHA512;
8865 salt_type = SALT_TYPE_EMBEDDED;
8866 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8867 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8868 kern_type = KERN_TYPE_DRUPAL7;
8869 dgst_size = DGST_SIZE_8_8;
8870 parse_func = drupal7_parse_hash;
8871 sort_by_digest = sort_by_digest_8_8;
8872 opti_type = OPTI_TYPE_ZERO_BYTE;
8873 dgst_pos0 = 0;
8874 dgst_pos1 = 1;
8875 dgst_pos2 = 2;
8876 dgst_pos3 = 3;
8877 break;
8878
8879 case 8000: hash_type = HASH_TYPE_SHA256;
8880 salt_type = SALT_TYPE_EMBEDDED;
8881 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8882 opts_type = OPTS_TYPE_PT_GENERATE_BE
8883 | OPTS_TYPE_PT_UNICODE
8884 | OPTS_TYPE_ST_ADD80
8885 | OPTS_TYPE_ST_HEX;
8886 kern_type = KERN_TYPE_SYBASEASE;
8887 dgst_size = DGST_SIZE_4_8;
8888 parse_func = sybasease_parse_hash;
8889 sort_by_digest = sort_by_digest_4_8;
8890 opti_type = OPTI_TYPE_ZERO_BYTE
8891 | OPTI_TYPE_PRECOMPUTE_INIT
8892 | OPTI_TYPE_EARLY_SKIP
8893 | OPTI_TYPE_NOT_ITERATED
8894 | OPTI_TYPE_RAW_HASH;
8895 dgst_pos0 = 3;
8896 dgst_pos1 = 7;
8897 dgst_pos2 = 2;
8898 dgst_pos3 = 6;
8899 break;
8900
8901 case 8100: hash_type = HASH_TYPE_SHA1;
8902 salt_type = SALT_TYPE_EMBEDDED;
8903 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8904 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8905 kern_type = KERN_TYPE_NETSCALER;
8906 dgst_size = DGST_SIZE_4_5;
8907 parse_func = netscaler_parse_hash;
8908 sort_by_digest = sort_by_digest_4_5;
8909 opti_type = OPTI_TYPE_ZERO_BYTE
8910 | OPTI_TYPE_PRECOMPUTE_INIT
8911 | OPTI_TYPE_PRECOMPUTE_MERKLE
8912 | OPTI_TYPE_EARLY_SKIP
8913 | OPTI_TYPE_NOT_ITERATED
8914 | OPTI_TYPE_PREPENDED_SALT
8915 | OPTI_TYPE_RAW_HASH;
8916 dgst_pos0 = 3;
8917 dgst_pos1 = 4;
8918 dgst_pos2 = 2;
8919 dgst_pos3 = 1;
8920 break;
8921
8922 case 8200: hash_type = HASH_TYPE_SHA256;
8923 salt_type = SALT_TYPE_EMBEDDED;
8924 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8925 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8926 kern_type = KERN_TYPE_CLOUDKEY;
8927 dgst_size = DGST_SIZE_4_8;
8928 parse_func = cloudkey_parse_hash;
8929 sort_by_digest = sort_by_digest_4_8;
8930 opti_type = OPTI_TYPE_ZERO_BYTE;
8931 dgst_pos0 = 0;
8932 dgst_pos1 = 1;
8933 dgst_pos2 = 2;
8934 dgst_pos3 = 3;
8935 break;
8936
8937 case 8300: hash_type = HASH_TYPE_SHA1;
8938 salt_type = SALT_TYPE_EMBEDDED;
8939 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8940 opts_type = OPTS_TYPE_PT_GENERATE_LE
8941 | OPTS_TYPE_ST_HEX
8942 | OPTS_TYPE_ST_ADD80;
8943 kern_type = KERN_TYPE_NSEC3;
8944 dgst_size = DGST_SIZE_4_5;
8945 parse_func = nsec3_parse_hash;
8946 sort_by_digest = sort_by_digest_4_5;
8947 opti_type = OPTI_TYPE_ZERO_BYTE;
8948 dgst_pos0 = 3;
8949 dgst_pos1 = 4;
8950 dgst_pos2 = 2;
8951 dgst_pos3 = 1;
8952 break;
8953
8954 case 8400: hash_type = HASH_TYPE_SHA1;
8955 salt_type = SALT_TYPE_INTERN;
8956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8957 opts_type = OPTS_TYPE_PT_GENERATE_BE
8958 | OPTS_TYPE_PT_ADD80
8959 | OPTS_TYPE_PT_ADDBITS15;
8960 kern_type = KERN_TYPE_WBB3;
8961 dgst_size = DGST_SIZE_4_5;
8962 parse_func = wbb3_parse_hash;
8963 sort_by_digest = sort_by_digest_4_5;
8964 opti_type = OPTI_TYPE_ZERO_BYTE
8965 | OPTI_TYPE_PRECOMPUTE_INIT
8966 | OPTI_TYPE_NOT_ITERATED;
8967 dgst_pos0 = 3;
8968 dgst_pos1 = 4;
8969 dgst_pos2 = 2;
8970 dgst_pos3 = 1;
8971 break;
8972
8973 case 8500: hash_type = HASH_TYPE_DESRACF;
8974 salt_type = SALT_TYPE_EMBEDDED;
8975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8976 opts_type = OPTS_TYPE_PT_GENERATE_LE
8977 | OPTS_TYPE_ST_UPPER;
8978 kern_type = KERN_TYPE_RACF;
8979 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8980 parse_func = racf_parse_hash;
8981 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8982 opti_type = OPTI_TYPE_ZERO_BYTE
8983 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8984 dgst_pos0 = 0;
8985 dgst_pos1 = 1;
8986 dgst_pos2 = 2;
8987 dgst_pos3 = 3;
8988 break;
8989
8990 case 8600: hash_type = HASH_TYPE_LOTUS5;
8991 salt_type = SALT_TYPE_NONE;
8992 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8993 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8994 kern_type = KERN_TYPE_LOTUS5;
8995 dgst_size = DGST_SIZE_4_4;
8996 parse_func = lotus5_parse_hash;
8997 sort_by_digest = sort_by_digest_4_4;
8998 opti_type = OPTI_TYPE_EARLY_SKIP
8999 | OPTI_TYPE_NOT_ITERATED
9000 | OPTI_TYPE_NOT_SALTED
9001 | OPTI_TYPE_RAW_HASH;
9002 dgst_pos0 = 0;
9003 dgst_pos1 = 1;
9004 dgst_pos2 = 2;
9005 dgst_pos3 = 3;
9006 break;
9007
9008 case 8700: hash_type = HASH_TYPE_LOTUS6;
9009 salt_type = SALT_TYPE_EMBEDDED;
9010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9011 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9012 kern_type = KERN_TYPE_LOTUS6;
9013 dgst_size = DGST_SIZE_4_4;
9014 parse_func = lotus6_parse_hash;
9015 sort_by_digest = sort_by_digest_4_4;
9016 opti_type = OPTI_TYPE_EARLY_SKIP
9017 | OPTI_TYPE_NOT_ITERATED
9018 | OPTI_TYPE_RAW_HASH;
9019 dgst_pos0 = 0;
9020 dgst_pos1 = 1;
9021 dgst_pos2 = 2;
9022 dgst_pos3 = 3;
9023 break;
9024
9025 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9026 salt_type = SALT_TYPE_EMBEDDED;
9027 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9028 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9029 kern_type = KERN_TYPE_ANDROIDFDE;
9030 dgst_size = DGST_SIZE_4_4;
9031 parse_func = androidfde_parse_hash;
9032 sort_by_digest = sort_by_digest_4_4;
9033 opti_type = OPTI_TYPE_ZERO_BYTE;
9034 dgst_pos0 = 0;
9035 dgst_pos1 = 1;
9036 dgst_pos2 = 2;
9037 dgst_pos3 = 3;
9038 break;
9039
9040 case 8900: hash_type = HASH_TYPE_SCRYPT;
9041 salt_type = SALT_TYPE_EMBEDDED;
9042 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9043 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9044 kern_type = KERN_TYPE_SCRYPT;
9045 dgst_size = DGST_SIZE_4_8;
9046 parse_func = scrypt_parse_hash;
9047 sort_by_digest = sort_by_digest_4_8;
9048 opti_type = OPTI_TYPE_ZERO_BYTE;
9049 dgst_pos0 = 0;
9050 dgst_pos1 = 1;
9051 dgst_pos2 = 2;
9052 dgst_pos3 = 3;
9053 break;
9054
9055 case 9000: hash_type = HASH_TYPE_SHA1;
9056 salt_type = SALT_TYPE_EMBEDDED;
9057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9058 opts_type = OPTS_TYPE_PT_GENERATE_LE
9059 | OPTS_TYPE_ST_GENERATE_LE;
9060 kern_type = KERN_TYPE_PSAFE2;
9061 dgst_size = DGST_SIZE_4_5;
9062 parse_func = psafe2_parse_hash;
9063 sort_by_digest = sort_by_digest_4_5;
9064 opti_type = OPTI_TYPE_ZERO_BYTE;
9065 dgst_pos0 = 0;
9066 dgst_pos1 = 1;
9067 dgst_pos2 = 2;
9068 dgst_pos3 = 3;
9069 break;
9070
9071 case 9100: hash_type = HASH_TYPE_LOTUS8;
9072 salt_type = SALT_TYPE_EMBEDDED;
9073 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9074 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9075 kern_type = KERN_TYPE_LOTUS8;
9076 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9077 parse_func = lotus8_parse_hash;
9078 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9079 opti_type = OPTI_TYPE_ZERO_BYTE;
9080 dgst_pos0 = 0;
9081 dgst_pos1 = 1;
9082 dgst_pos2 = 2;
9083 dgst_pos3 = 3;
9084 break;
9085
9086 case 9200: hash_type = HASH_TYPE_SHA256;
9087 salt_type = SALT_TYPE_EMBEDDED;
9088 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9089 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9090 kern_type = KERN_TYPE_PBKDF2_SHA256;
9091 dgst_size = DGST_SIZE_4_32;
9092 parse_func = cisco8_parse_hash;
9093 sort_by_digest = sort_by_digest_4_32;
9094 opti_type = OPTI_TYPE_ZERO_BYTE;
9095 dgst_pos0 = 0;
9096 dgst_pos1 = 1;
9097 dgst_pos2 = 2;
9098 dgst_pos3 = 3;
9099 break;
9100
9101 case 9300: hash_type = HASH_TYPE_SCRYPT;
9102 salt_type = SALT_TYPE_EMBEDDED;
9103 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9104 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9105 kern_type = KERN_TYPE_SCRYPT;
9106 dgst_size = DGST_SIZE_4_8;
9107 parse_func = cisco9_parse_hash;
9108 sort_by_digest = sort_by_digest_4_8;
9109 opti_type = OPTI_TYPE_ZERO_BYTE;
9110 dgst_pos0 = 0;
9111 dgst_pos1 = 1;
9112 dgst_pos2 = 2;
9113 dgst_pos3 = 3;
9114 break;
9115
9116 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9117 salt_type = SALT_TYPE_EMBEDDED;
9118 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9119 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9120 kern_type = KERN_TYPE_OFFICE2007;
9121 dgst_size = DGST_SIZE_4_4;
9122 parse_func = office2007_parse_hash;
9123 sort_by_digest = sort_by_digest_4_4;
9124 opti_type = OPTI_TYPE_ZERO_BYTE;
9125 dgst_pos0 = 0;
9126 dgst_pos1 = 1;
9127 dgst_pos2 = 2;
9128 dgst_pos3 = 3;
9129 break;
9130
9131 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9132 salt_type = SALT_TYPE_EMBEDDED;
9133 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9134 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9135 kern_type = KERN_TYPE_OFFICE2010;
9136 dgst_size = DGST_SIZE_4_4;
9137 parse_func = office2010_parse_hash;
9138 sort_by_digest = sort_by_digest_4_4;
9139 opti_type = OPTI_TYPE_ZERO_BYTE;
9140 dgst_pos0 = 0;
9141 dgst_pos1 = 1;
9142 dgst_pos2 = 2;
9143 dgst_pos3 = 3;
9144 break;
9145
9146 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9147 salt_type = SALT_TYPE_EMBEDDED;
9148 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9149 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9150 kern_type = KERN_TYPE_OFFICE2013;
9151 dgst_size = DGST_SIZE_4_4;
9152 parse_func = office2013_parse_hash;
9153 sort_by_digest = sort_by_digest_4_4;
9154 opti_type = OPTI_TYPE_ZERO_BYTE;
9155 dgst_pos0 = 0;
9156 dgst_pos1 = 1;
9157 dgst_pos2 = 2;
9158 dgst_pos3 = 3;
9159 break;
9160
9161 case 9700: 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 | OPTS_TYPE_PT_UNICODE;
9167 kern_type = KERN_TYPE_OLDOFFICE01;
9168 dgst_size = DGST_SIZE_4_4;
9169 parse_func = oldoffice01_parse_hash;
9170 sort_by_digest = sort_by_digest_4_4;
9171 opti_type = OPTI_TYPE_ZERO_BYTE
9172 | OPTI_TYPE_PRECOMPUTE_INIT
9173 | OPTI_TYPE_NOT_ITERATED;
9174 dgst_pos0 = 0;
9175 dgst_pos1 = 1;
9176 dgst_pos2 = 2;
9177 dgst_pos3 = 3;
9178 break;
9179
9180 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9181 salt_type = SALT_TYPE_EMBEDDED;
9182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9183 opts_type = OPTS_TYPE_PT_GENERATE_LE
9184 | OPTS_TYPE_PT_ADD80;
9185 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9186 dgst_size = DGST_SIZE_4_4;
9187 parse_func = oldoffice01cm1_parse_hash;
9188 sort_by_digest = sort_by_digest_4_4;
9189 opti_type = OPTI_TYPE_ZERO_BYTE
9190 | OPTI_TYPE_PRECOMPUTE_INIT
9191 | OPTI_TYPE_NOT_ITERATED;
9192 dgst_pos0 = 0;
9193 dgst_pos1 = 1;
9194 dgst_pos2 = 2;
9195 dgst_pos3 = 3;
9196 break;
9197
9198 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9199 salt_type = SALT_TYPE_EMBEDDED;
9200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9201 opts_type = OPTS_TYPE_PT_GENERATE_LE
9202 | OPTS_TYPE_PT_ADD80
9203 | OPTS_TYPE_PT_UNICODE
9204 | OPTS_TYPE_PT_NEVERCRACK;
9205 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9206 dgst_size = DGST_SIZE_4_4;
9207 parse_func = oldoffice01cm2_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 9800: 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_BE
9222 | OPTS_TYPE_PT_ADD80
9223 | OPTS_TYPE_PT_UNICODE;
9224 kern_type = KERN_TYPE_OLDOFFICE34;
9225 dgst_size = DGST_SIZE_4_4;
9226 parse_func = oldoffice34_parse_hash;
9227 sort_by_digest = sort_by_digest_4_4;
9228 opti_type = OPTI_TYPE_ZERO_BYTE
9229 | OPTI_TYPE_PRECOMPUTE_INIT
9230 | OPTI_TYPE_NOT_ITERATED;
9231 dgst_pos0 = 0;
9232 dgst_pos1 = 1;
9233 dgst_pos2 = 2;
9234 dgst_pos3 = 3;
9235 break;
9236
9237 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9238 salt_type = SALT_TYPE_EMBEDDED;
9239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9240 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9241 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9242 dgst_size = DGST_SIZE_4_4;
9243 parse_func = oldoffice34cm1_parse_hash;
9244 sort_by_digest = sort_by_digest_4_4;
9245 opti_type = OPTI_TYPE_ZERO_BYTE
9246 | OPTI_TYPE_PRECOMPUTE_INIT
9247 | OPTI_TYPE_NOT_ITERATED;
9248 dgst_pos0 = 0;
9249 dgst_pos1 = 1;
9250 dgst_pos2 = 2;
9251 dgst_pos3 = 3;
9252 break;
9253
9254 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9255 salt_type = SALT_TYPE_EMBEDDED;
9256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9257 opts_type = OPTS_TYPE_PT_GENERATE_BE
9258 | OPTS_TYPE_PT_ADD80
9259 | OPTS_TYPE_PT_UNICODE
9260 | OPTS_TYPE_PT_NEVERCRACK;
9261 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9262 dgst_size = DGST_SIZE_4_4;
9263 parse_func = oldoffice34cm2_parse_hash;
9264 sort_by_digest = sort_by_digest_4_4;
9265 opti_type = OPTI_TYPE_ZERO_BYTE
9266 | OPTI_TYPE_PRECOMPUTE_INIT
9267 | OPTI_TYPE_NOT_ITERATED;
9268 dgst_pos0 = 0;
9269 dgst_pos1 = 1;
9270 dgst_pos2 = 2;
9271 dgst_pos3 = 3;
9272 break;
9273
9274 case 9900: hash_type = HASH_TYPE_MD5;
9275 salt_type = SALT_TYPE_NONE;
9276 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9277 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9278 kern_type = KERN_TYPE_RADMIN2;
9279 dgst_size = DGST_SIZE_4_4;
9280 parse_func = radmin2_parse_hash;
9281 sort_by_digest = sort_by_digest_4_4;
9282 opti_type = OPTI_TYPE_ZERO_BYTE
9283 | OPTI_TYPE_PRECOMPUTE_INIT
9284 | OPTI_TYPE_EARLY_SKIP
9285 | OPTI_TYPE_NOT_ITERATED
9286 | OPTI_TYPE_NOT_SALTED;
9287 dgst_pos0 = 0;
9288 dgst_pos1 = 3;
9289 dgst_pos2 = 2;
9290 dgst_pos3 = 1;
9291 break;
9292
9293 case 10000: hash_type = HASH_TYPE_SHA256;
9294 salt_type = SALT_TYPE_EMBEDDED;
9295 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9296 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9297 kern_type = KERN_TYPE_PBKDF2_SHA256;
9298 dgst_size = DGST_SIZE_4_32;
9299 parse_func = djangopbkdf2_parse_hash;
9300 sort_by_digest = sort_by_digest_4_32;
9301 opti_type = OPTI_TYPE_ZERO_BYTE;
9302 dgst_pos0 = 0;
9303 dgst_pos1 = 1;
9304 dgst_pos2 = 2;
9305 dgst_pos3 = 3;
9306 break;
9307
9308 case 10100: hash_type = HASH_TYPE_SIPHASH;
9309 salt_type = SALT_TYPE_EMBEDDED;
9310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9311 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9312 kern_type = KERN_TYPE_SIPHASH;
9313 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9314 parse_func = siphash_parse_hash;
9315 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9316 opti_type = OPTI_TYPE_ZERO_BYTE
9317 | OPTI_TYPE_NOT_ITERATED
9318 | OPTI_TYPE_RAW_HASH;
9319 dgst_pos0 = 0;
9320 dgst_pos1 = 1;
9321 dgst_pos2 = 2;
9322 dgst_pos3 = 3;
9323 break;
9324
9325 case 10200: hash_type = HASH_TYPE_MD5;
9326 salt_type = SALT_TYPE_EMBEDDED;
9327 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9328 opts_type = OPTS_TYPE_PT_GENERATE_LE
9329 | OPTS_TYPE_ST_ADD80
9330 | OPTS_TYPE_ST_ADDBITS14;
9331 kern_type = KERN_TYPE_HMACMD5_PW;
9332 dgst_size = DGST_SIZE_4_4;
9333 parse_func = crammd5_parse_hash;
9334 sort_by_digest = sort_by_digest_4_4;
9335 opti_type = OPTI_TYPE_ZERO_BYTE
9336 | OPTI_TYPE_NOT_ITERATED;
9337 dgst_pos0 = 0;
9338 dgst_pos1 = 3;
9339 dgst_pos2 = 2;
9340 dgst_pos3 = 1;
9341 break;
9342
9343 case 10300: hash_type = HASH_TYPE_SHA1;
9344 salt_type = SALT_TYPE_EMBEDDED;
9345 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9346 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9347 kern_type = KERN_TYPE_SAPH_SHA1;
9348 dgst_size = DGST_SIZE_4_5;
9349 parse_func = saph_sha1_parse_hash;
9350 sort_by_digest = sort_by_digest_4_5;
9351 opti_type = OPTI_TYPE_ZERO_BYTE;
9352 dgst_pos0 = 0;
9353 dgst_pos1 = 1;
9354 dgst_pos2 = 2;
9355 dgst_pos3 = 3;
9356 break;
9357
9358 case 10400: hash_type = HASH_TYPE_PDFU16;
9359 salt_type = SALT_TYPE_EMBEDDED;
9360 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9361 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9362 kern_type = KERN_TYPE_PDF11;
9363 dgst_size = DGST_SIZE_4_4;
9364 parse_func = pdf11_parse_hash;
9365 sort_by_digest = sort_by_digest_4_4;
9366 opti_type = OPTI_TYPE_ZERO_BYTE
9367 | OPTI_TYPE_NOT_ITERATED;
9368 dgst_pos0 = 0;
9369 dgst_pos1 = 1;
9370 dgst_pos2 = 2;
9371 dgst_pos3 = 3;
9372 break;
9373
9374 case 10410: hash_type = HASH_TYPE_PDFU16;
9375 salt_type = SALT_TYPE_EMBEDDED;
9376 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9377 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9378 kern_type = KERN_TYPE_PDF11CM1;
9379 dgst_size = DGST_SIZE_4_4;
9380 parse_func = pdf11cm1_parse_hash;
9381 sort_by_digest = sort_by_digest_4_4;
9382 opti_type = OPTI_TYPE_ZERO_BYTE
9383 | OPTI_TYPE_NOT_ITERATED;
9384 dgst_pos0 = 0;
9385 dgst_pos1 = 1;
9386 dgst_pos2 = 2;
9387 dgst_pos3 = 3;
9388 break;
9389
9390 case 10420: hash_type = HASH_TYPE_PDFU16;
9391 salt_type = SALT_TYPE_EMBEDDED;
9392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9393 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9394 kern_type = KERN_TYPE_PDF11CM2;
9395 dgst_size = DGST_SIZE_4_4;
9396 parse_func = pdf11cm2_parse_hash;
9397 sort_by_digest = sort_by_digest_4_4;
9398 opti_type = OPTI_TYPE_ZERO_BYTE
9399 | OPTI_TYPE_NOT_ITERATED;
9400 dgst_pos0 = 0;
9401 dgst_pos1 = 1;
9402 dgst_pos2 = 2;
9403 dgst_pos3 = 3;
9404 break;
9405
9406 case 10500: hash_type = HASH_TYPE_PDFU16;
9407 salt_type = SALT_TYPE_EMBEDDED;
9408 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9409 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9410 kern_type = KERN_TYPE_PDF14;
9411 dgst_size = DGST_SIZE_4_4;
9412 parse_func = pdf14_parse_hash;
9413 sort_by_digest = sort_by_digest_4_4;
9414 opti_type = OPTI_TYPE_ZERO_BYTE
9415 | OPTI_TYPE_NOT_ITERATED;
9416 dgst_pos0 = 0;
9417 dgst_pos1 = 1;
9418 dgst_pos2 = 2;
9419 dgst_pos3 = 3;
9420 break;
9421
9422 case 10600: hash_type = HASH_TYPE_SHA256;
9423 salt_type = SALT_TYPE_EMBEDDED;
9424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9425 opts_type = OPTS_TYPE_PT_GENERATE_BE
9426 | OPTS_TYPE_ST_ADD80
9427 | OPTS_TYPE_ST_ADDBITS15
9428 | OPTS_TYPE_HASH_COPY;
9429 kern_type = KERN_TYPE_SHA256_PWSLT;
9430 dgst_size = DGST_SIZE_4_8;
9431 parse_func = pdf17l3_parse_hash;
9432 sort_by_digest = sort_by_digest_4_8;
9433 opti_type = OPTI_TYPE_ZERO_BYTE
9434 | OPTI_TYPE_PRECOMPUTE_INIT
9435 | OPTI_TYPE_PRECOMPUTE_MERKLE
9436 | OPTI_TYPE_EARLY_SKIP
9437 | OPTI_TYPE_NOT_ITERATED
9438 | OPTI_TYPE_APPENDED_SALT
9439 | OPTI_TYPE_RAW_HASH;
9440 dgst_pos0 = 3;
9441 dgst_pos1 = 7;
9442 dgst_pos2 = 2;
9443 dgst_pos3 = 6;
9444 break;
9445
9446 case 10700: hash_type = HASH_TYPE_PDFU32;
9447 salt_type = SALT_TYPE_EMBEDDED;
9448 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9449 opts_type = OPTS_TYPE_PT_GENERATE_LE
9450 | OPTS_TYPE_HASH_COPY;
9451 kern_type = KERN_TYPE_PDF17L8;
9452 dgst_size = DGST_SIZE_4_8;
9453 parse_func = pdf17l8_parse_hash;
9454 sort_by_digest = sort_by_digest_4_8;
9455 opti_type = OPTI_TYPE_ZERO_BYTE
9456 | OPTI_TYPE_NOT_ITERATED;
9457 dgst_pos0 = 0;
9458 dgst_pos1 = 1;
9459 dgst_pos2 = 2;
9460 dgst_pos3 = 3;
9461 break;
9462
9463 case 10800: hash_type = HASH_TYPE_SHA384;
9464 salt_type = SALT_TYPE_NONE;
9465 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9466 opts_type = OPTS_TYPE_PT_GENERATE_BE
9467 | OPTS_TYPE_PT_ADD80
9468 | OPTS_TYPE_PT_ADDBITS15;
9469 kern_type = KERN_TYPE_SHA384;
9470 dgst_size = DGST_SIZE_8_8;
9471 parse_func = sha384_parse_hash;
9472 sort_by_digest = sort_by_digest_8_8;
9473 opti_type = OPTI_TYPE_ZERO_BYTE
9474 | OPTI_TYPE_PRECOMPUTE_INIT
9475 | OPTI_TYPE_PRECOMPUTE_MERKLE
9476 | OPTI_TYPE_EARLY_SKIP
9477 | OPTI_TYPE_NOT_ITERATED
9478 | OPTI_TYPE_NOT_SALTED
9479 | OPTI_TYPE_RAW_HASH;
9480 dgst_pos0 = 6;
9481 dgst_pos1 = 7;
9482 dgst_pos2 = 4;
9483 dgst_pos3 = 5;
9484 break;
9485
9486 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9487 salt_type = SALT_TYPE_EMBEDDED;
9488 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9489 opts_type = OPTS_TYPE_PT_GENERATE_LE
9490 | OPTS_TYPE_ST_BASE64
9491 | OPTS_TYPE_HASH_COPY;
9492 kern_type = KERN_TYPE_PBKDF2_SHA256;
9493 dgst_size = DGST_SIZE_4_32;
9494 parse_func = pbkdf2_sha256_parse_hash;
9495 sort_by_digest = sort_by_digest_4_32;
9496 opti_type = OPTI_TYPE_ZERO_BYTE;
9497 dgst_pos0 = 0;
9498 dgst_pos1 = 1;
9499 dgst_pos2 = 2;
9500 dgst_pos3 = 3;
9501 break;
9502
9503 case 11000: hash_type = HASH_TYPE_MD5;
9504 salt_type = SALT_TYPE_INTERN;
9505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9506 opts_type = OPTS_TYPE_PT_GENERATE_LE
9507 | OPTS_TYPE_PT_ADD80;
9508 kern_type = KERN_TYPE_PRESTASHOP;
9509 dgst_size = DGST_SIZE_4_4;
9510 parse_func = prestashop_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_NOT_ITERATED
9515 | OPTI_TYPE_PREPENDED_SALT;
9516 dgst_pos0 = 0;
9517 dgst_pos1 = 3;
9518 dgst_pos2 = 2;
9519 dgst_pos3 = 1;
9520 break;
9521
9522 case 11100: hash_type = HASH_TYPE_MD5;
9523 salt_type = SALT_TYPE_EMBEDDED;
9524 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9525 opts_type = OPTS_TYPE_PT_GENERATE_LE
9526 | OPTS_TYPE_ST_ADD80;
9527 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9528 dgst_size = DGST_SIZE_4_4;
9529 parse_func = postgresql_auth_parse_hash;
9530 sort_by_digest = sort_by_digest_4_4;
9531 opti_type = OPTI_TYPE_ZERO_BYTE
9532 | OPTI_TYPE_PRECOMPUTE_INIT
9533 | OPTI_TYPE_PRECOMPUTE_MERKLE
9534 | OPTI_TYPE_EARLY_SKIP;
9535 dgst_pos0 = 0;
9536 dgst_pos1 = 3;
9537 dgst_pos2 = 2;
9538 dgst_pos3 = 1;
9539 break;
9540
9541 case 11200: hash_type = HASH_TYPE_SHA1;
9542 salt_type = SALT_TYPE_EMBEDDED;
9543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9544 opts_type = OPTS_TYPE_PT_GENERATE_BE
9545 | OPTS_TYPE_PT_ADD80
9546 | OPTS_TYPE_ST_HEX;
9547 kern_type = KERN_TYPE_MYSQL_AUTH;
9548 dgst_size = DGST_SIZE_4_5;
9549 parse_func = mysql_auth_parse_hash;
9550 sort_by_digest = sort_by_digest_4_5;
9551 opti_type = OPTI_TYPE_ZERO_BYTE
9552 | OPTI_TYPE_EARLY_SKIP;
9553 dgst_pos0 = 3;
9554 dgst_pos1 = 4;
9555 dgst_pos2 = 2;
9556 dgst_pos3 = 1;
9557 break;
9558
9559 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9560 salt_type = SALT_TYPE_EMBEDDED;
9561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9562 opts_type = OPTS_TYPE_PT_GENERATE_LE
9563 | OPTS_TYPE_ST_HEX
9564 | OPTS_TYPE_ST_ADD80;
9565 kern_type = KERN_TYPE_BITCOIN_WALLET;
9566 dgst_size = DGST_SIZE_4_4;
9567 parse_func = bitcoin_wallet_parse_hash;
9568 sort_by_digest = sort_by_digest_4_4;
9569 opti_type = OPTI_TYPE_ZERO_BYTE;
9570 dgst_pos0 = 0;
9571 dgst_pos1 = 1;
9572 dgst_pos2 = 2;
9573 dgst_pos3 = 3;
9574 break;
9575
9576 case 11400: hash_type = HASH_TYPE_MD5;
9577 salt_type = SALT_TYPE_EMBEDDED;
9578 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9579 opts_type = OPTS_TYPE_PT_GENERATE_LE
9580 | OPTS_TYPE_PT_ADD80
9581 | OPTS_TYPE_HASH_COPY;
9582 kern_type = KERN_TYPE_SIP_AUTH;
9583 dgst_size = DGST_SIZE_4_4;
9584 parse_func = sip_auth_parse_hash;
9585 sort_by_digest = sort_by_digest_4_4;
9586 opti_type = OPTI_TYPE_ZERO_BYTE;
9587 dgst_pos0 = 0;
9588 dgst_pos1 = 3;
9589 dgst_pos2 = 2;
9590 dgst_pos3 = 1;
9591 break;
9592
9593 case 11500: hash_type = HASH_TYPE_CRC32;
9594 salt_type = SALT_TYPE_INTERN;
9595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9596 opts_type = OPTS_TYPE_PT_GENERATE_LE
9597 | OPTS_TYPE_ST_GENERATE_LE
9598 | OPTS_TYPE_ST_HEX;
9599 kern_type = KERN_TYPE_CRC32;
9600 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9601 parse_func = crc32_parse_hash;
9602 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9603 opti_type = OPTI_TYPE_ZERO_BYTE;
9604 dgst_pos0 = 0;
9605 dgst_pos1 = 1;
9606 dgst_pos2 = 2;
9607 dgst_pos3 = 3;
9608 break;
9609
9610 case 11600: hash_type = HASH_TYPE_AES;
9611 salt_type = SALT_TYPE_EMBEDDED;
9612 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9613 opts_type = OPTS_TYPE_PT_GENERATE_LE
9614 | OPTS_TYPE_PT_NEVERCRACK;
9615 kern_type = KERN_TYPE_SEVEN_ZIP;
9616 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9617 parse_func = seven_zip_parse_hash;
9618 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9619 opti_type = OPTI_TYPE_ZERO_BYTE;
9620 dgst_pos0 = 0;
9621 dgst_pos1 = 1;
9622 dgst_pos2 = 2;
9623 dgst_pos3 = 3;
9624 break;
9625
9626 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9627 salt_type = SALT_TYPE_NONE;
9628 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9629 opts_type = OPTS_TYPE_PT_GENERATE_LE
9630 | OPTS_TYPE_PT_ADD01;
9631 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9632 dgst_size = DGST_SIZE_4_8;
9633 parse_func = gost2012sbog_256_parse_hash;
9634 sort_by_digest = sort_by_digest_4_8;
9635 opti_type = OPTI_TYPE_ZERO_BYTE;
9636 dgst_pos0 = 0;
9637 dgst_pos1 = 1;
9638 dgst_pos2 = 2;
9639 dgst_pos3 = 3;
9640 break;
9641
9642 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9643 salt_type = SALT_TYPE_NONE;
9644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9645 opts_type = OPTS_TYPE_PT_GENERATE_LE
9646 | OPTS_TYPE_PT_ADD01;
9647 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9648 dgst_size = DGST_SIZE_4_16;
9649 parse_func = gost2012sbog_512_parse_hash;
9650 sort_by_digest = sort_by_digest_4_16;
9651 opti_type = OPTI_TYPE_ZERO_BYTE;
9652 dgst_pos0 = 0;
9653 dgst_pos1 = 1;
9654 dgst_pos2 = 2;
9655 dgst_pos3 = 3;
9656 break;
9657
9658 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9659 salt_type = SALT_TYPE_EMBEDDED;
9660 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9661 opts_type = OPTS_TYPE_PT_GENERATE_LE
9662 | OPTS_TYPE_ST_BASE64
9663 | OPTS_TYPE_HASH_COPY;
9664 kern_type = KERN_TYPE_PBKDF2_MD5;
9665 dgst_size = DGST_SIZE_4_32;
9666 parse_func = pbkdf2_md5_parse_hash;
9667 sort_by_digest = sort_by_digest_4_32;
9668 opti_type = OPTI_TYPE_ZERO_BYTE;
9669 dgst_pos0 = 0;
9670 dgst_pos1 = 1;
9671 dgst_pos2 = 2;
9672 dgst_pos3 = 3;
9673 break;
9674
9675 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9676 salt_type = SALT_TYPE_EMBEDDED;
9677 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9678 opts_type = OPTS_TYPE_PT_GENERATE_LE
9679 | OPTS_TYPE_ST_BASE64
9680 | OPTS_TYPE_HASH_COPY;
9681 kern_type = KERN_TYPE_PBKDF2_SHA1;
9682 dgst_size = DGST_SIZE_4_32;
9683 parse_func = pbkdf2_sha1_parse_hash;
9684 sort_by_digest = sort_by_digest_4_32;
9685 opti_type = OPTI_TYPE_ZERO_BYTE;
9686 dgst_pos0 = 0;
9687 dgst_pos1 = 1;
9688 dgst_pos2 = 2;
9689 dgst_pos3 = 3;
9690 break;
9691
9692 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9693 salt_type = SALT_TYPE_EMBEDDED;
9694 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9695 opts_type = OPTS_TYPE_PT_GENERATE_LE
9696 | OPTS_TYPE_ST_BASE64
9697 | OPTS_TYPE_HASH_COPY;
9698 kern_type = KERN_TYPE_PBKDF2_SHA512;
9699 dgst_size = DGST_SIZE_8_16;
9700 parse_func = pbkdf2_sha512_parse_hash;
9701 sort_by_digest = sort_by_digest_8_16;
9702 opti_type = OPTI_TYPE_ZERO_BYTE;
9703 dgst_pos0 = 0;
9704 dgst_pos1 = 1;
9705 dgst_pos2 = 2;
9706 dgst_pos3 = 3;
9707 break;
9708
9709 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9710 salt_type = SALT_TYPE_EMBEDDED;
9711 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9712 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9713 kern_type = KERN_TYPE_ECRYPTFS;
9714 dgst_size = DGST_SIZE_8_8;
9715 parse_func = ecryptfs_parse_hash;
9716 sort_by_digest = sort_by_digest_8_8;
9717 opti_type = OPTI_TYPE_ZERO_BYTE;
9718 dgst_pos0 = 0;
9719 dgst_pos1 = 1;
9720 dgst_pos2 = 2;
9721 dgst_pos3 = 3;
9722 break;
9723
9724 case 12300: hash_type = HASH_TYPE_ORACLET;
9725 salt_type = SALT_TYPE_EMBEDDED;
9726 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9727 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9728 kern_type = KERN_TYPE_ORACLET;
9729 dgst_size = DGST_SIZE_8_16;
9730 parse_func = oraclet_parse_hash;
9731 sort_by_digest = sort_by_digest_8_16;
9732 opti_type = OPTI_TYPE_ZERO_BYTE;
9733 dgst_pos0 = 0;
9734 dgst_pos1 = 1;
9735 dgst_pos2 = 2;
9736 dgst_pos3 = 3;
9737 break;
9738
9739 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9740 salt_type = SALT_TYPE_EMBEDDED;
9741 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9742 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9743 kern_type = KERN_TYPE_BSDICRYPT;
9744 dgst_size = DGST_SIZE_4_4;
9745 parse_func = bsdicrypt_parse_hash;
9746 sort_by_digest = sort_by_digest_4_4;
9747 opti_type = OPTI_TYPE_ZERO_BYTE
9748 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9749 dgst_pos0 = 0;
9750 dgst_pos1 = 1;
9751 dgst_pos2 = 2;
9752 dgst_pos3 = 3;
9753 break;
9754
9755 case 12500: hash_type = HASH_TYPE_RAR3HP;
9756 salt_type = SALT_TYPE_EMBEDDED;
9757 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9758 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9759 kern_type = KERN_TYPE_RAR3;
9760 dgst_size = DGST_SIZE_4_4;
9761 parse_func = rar3hp_parse_hash;
9762 sort_by_digest = sort_by_digest_4_4;
9763 opti_type = OPTI_TYPE_ZERO_BYTE;
9764 dgst_pos0 = 0;
9765 dgst_pos1 = 1;
9766 dgst_pos2 = 2;
9767 dgst_pos3 = 3;
9768 break;
9769
9770 case 12600: hash_type = HASH_TYPE_SHA256;
9771 salt_type = SALT_TYPE_INTERN;
9772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9773 opts_type = OPTS_TYPE_PT_GENERATE_BE
9774 | OPTS_TYPE_PT_ADD80;
9775 kern_type = KERN_TYPE_CF10;
9776 dgst_size = DGST_SIZE_4_8;
9777 parse_func = cf10_parse_hash;
9778 sort_by_digest = sort_by_digest_4_8;
9779 opti_type = OPTI_TYPE_ZERO_BYTE
9780 | OPTI_TYPE_PRECOMPUTE_INIT
9781 | OPTI_TYPE_EARLY_SKIP
9782 | OPTI_TYPE_NOT_ITERATED;
9783 dgst_pos0 = 3;
9784 dgst_pos1 = 7;
9785 dgst_pos2 = 2;
9786 dgst_pos3 = 6;
9787 break;
9788
9789 case 12700: hash_type = HASH_TYPE_AES;
9790 salt_type = SALT_TYPE_EMBEDDED;
9791 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9792 opts_type = OPTS_TYPE_PT_GENERATE_LE
9793 | OPTS_TYPE_HASH_COPY;
9794 kern_type = KERN_TYPE_MYWALLET;
9795 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9796 parse_func = mywallet_parse_hash;
9797 sort_by_digest = sort_by_digest_4_5;
9798 opti_type = OPTI_TYPE_ZERO_BYTE;
9799 dgst_pos0 = 0;
9800 dgst_pos1 = 1;
9801 dgst_pos2 = 2;
9802 dgst_pos3 = 3;
9803 break;
9804
9805 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9806 salt_type = SALT_TYPE_EMBEDDED;
9807 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9808 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9809 kern_type = KERN_TYPE_MS_DRSR;
9810 dgst_size = DGST_SIZE_4_8;
9811 parse_func = ms_drsr_parse_hash;
9812 sort_by_digest = sort_by_digest_4_8;
9813 opti_type = OPTI_TYPE_ZERO_BYTE;
9814 dgst_pos0 = 0;
9815 dgst_pos1 = 1;
9816 dgst_pos2 = 2;
9817 dgst_pos3 = 3;
9818 break;
9819
9820 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9821 salt_type = SALT_TYPE_EMBEDDED;
9822 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9823 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9824 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
9825 dgst_size = DGST_SIZE_4_8;
9826 parse_func = androidfde_samsung_parse_hash;
9827 sort_by_digest = sort_by_digest_4_8;
9828 opti_type = OPTI_TYPE_ZERO_BYTE;
9829 dgst_pos0 = 0;
9830 dgst_pos1 = 1;
9831 dgst_pos2 = 2;
9832 dgst_pos3 = 3;
9833 break;
9834
9835 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
9836 salt_type = SALT_TYPE_EMBEDDED;
9837 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9838 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9839 kern_type = KERN_TYPE_RAR5;
9840 dgst_size = DGST_SIZE_4_4;
9841 parse_func = rar5_parse_hash;
9842 sort_by_digest = sort_by_digest_4_4;
9843 opti_type = OPTI_TYPE_ZERO_BYTE;
9844 dgst_pos0 = 0;
9845 dgst_pos1 = 1;
9846 dgst_pos2 = 2;
9847 dgst_pos3 = 3;
9848 break;
9849
9850 default: usage_mini_print (PROGNAME); return (-1);
9851 }
9852
9853 /**
9854 * transpose
9855 */
9856
9857 data.parse_func = parse_func;
9858
9859 /**
9860 * misc stuff
9861 */
9862
9863 if (hex_salt)
9864 {
9865 if (salt_type == SALT_TYPE_INTERN)
9866 {
9867 opts_type |= OPTS_TYPE_ST_HEX;
9868 }
9869 else
9870 {
9871 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9872
9873 return (-1);
9874 }
9875 }
9876
9877 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9878 | (salt_type == SALT_TYPE_EXTERN)
9879 | (salt_type == SALT_TYPE_EMBEDDED)
9880 | (salt_type == SALT_TYPE_VIRTUAL));
9881
9882 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9883
9884 data.hash_type = hash_type;
9885 data.attack_mode = attack_mode;
9886 data.attack_kern = attack_kern;
9887 data.attack_exec = attack_exec;
9888 data.kern_type = kern_type;
9889 data.opts_type = opts_type;
9890 data.dgst_size = dgst_size;
9891 data.salt_type = salt_type;
9892 data.isSalted = isSalted;
9893 data.sort_by_digest = sort_by_digest;
9894 data.dgst_pos0 = dgst_pos0;
9895 data.dgst_pos1 = dgst_pos1;
9896 data.dgst_pos2 = dgst_pos2;
9897 data.dgst_pos3 = dgst_pos3;
9898
9899 esalt_size = 0;
9900
9901 switch (hash_mode)
9902 {
9903 case 2500: esalt_size = sizeof (wpa_t); break;
9904 case 5300: esalt_size = sizeof (ikepsk_t); break;
9905 case 5400: esalt_size = sizeof (ikepsk_t); break;
9906 case 5500: esalt_size = sizeof (netntlm_t); break;
9907 case 5600: esalt_size = sizeof (netntlm_t); break;
9908 case 6211:
9909 case 6212:
9910 case 6213:
9911 case 6221:
9912 case 6222:
9913 case 6223:
9914 case 6231:
9915 case 6232:
9916 case 6233:
9917 case 6241:
9918 case 6242:
9919 case 6243: esalt_size = sizeof (tc_t); break;
9920 case 6600: esalt_size = sizeof (agilekey_t); break;
9921 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9922 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9923 case 7300: esalt_size = sizeof (rakp_t); break;
9924 case 7500: esalt_size = sizeof (krb5pa_t); break;
9925 case 8200: esalt_size = sizeof (cloudkey_t); break;
9926 case 8800: esalt_size = sizeof (androidfde_t); break;
9927 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9928 case 9400: esalt_size = sizeof (office2007_t); break;
9929 case 9500: esalt_size = sizeof (office2010_t); break;
9930 case 9600: esalt_size = sizeof (office2013_t); break;
9931 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9932 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9933 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9934 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9935 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9936 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9937 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9938 case 10200: esalt_size = sizeof (cram_md5_t); break;
9939 case 10400: esalt_size = sizeof (pdf_t); break;
9940 case 10410: esalt_size = sizeof (pdf_t); break;
9941 case 10420: esalt_size = sizeof (pdf_t); break;
9942 case 10500: esalt_size = sizeof (pdf_t); break;
9943 case 10600: esalt_size = sizeof (pdf_t); break;
9944 case 10700: esalt_size = sizeof (pdf_t); break;
9945 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9946 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9947 case 11400: esalt_size = sizeof (sip_t); break;
9948 case 11600: esalt_size = sizeof (seven_zip_t); break;
9949 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9950 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9951 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9952 case 13000: esalt_size = sizeof (rar5_t); break;
9953 }
9954
9955 data.esalt_size = esalt_size;
9956
9957 /**
9958 * choose dictionary parser
9959 */
9960
9961 if (hash_type == HASH_TYPE_LM)
9962 {
9963 get_next_word_func = get_next_word_lm;
9964 }
9965 else if (opts_type & OPTS_TYPE_PT_UPPER)
9966 {
9967 get_next_word_func = get_next_word_uc;
9968 }
9969 else
9970 {
9971 get_next_word_func = get_next_word_std;
9972 }
9973
9974 /**
9975 * dictstat
9976 */
9977
9978 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
9979
9980 #ifdef _POSIX
9981 size_t dictstat_nmemb = 0;
9982 #endif
9983
9984 #ifdef _WIN
9985 uint dictstat_nmemb = 0;
9986 #endif
9987
9988 char dictstat[256];
9989
9990 FILE *dictstat_fp = NULL;
9991
9992 if (keyspace == 0)
9993 {
9994 memset (dictstat, 0, sizeof (dictstat));
9995
9996 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
9997
9998 dictstat_fp = fopen (dictstat, "rb");
9999
10000 if (dictstat_fp)
10001 {
10002 #ifdef _POSIX
10003 struct stat tmpstat;
10004
10005 fstat (fileno (dictstat_fp), &tmpstat);
10006 #endif
10007
10008 #ifdef _WIN
10009 struct stat64 tmpstat;
10010
10011 _fstat64 (fileno (dictstat_fp), &tmpstat);
10012 #endif
10013
10014 if (tmpstat.st_mtime < COMPTIME)
10015 {
10016 /* with v0.15 the format changed so we have to ensure user is using a good version
10017 since there is no version-header in the dictstat file */
10018
10019 fclose (dictstat_fp);
10020
10021 unlink (dictstat);
10022 }
10023 else
10024 {
10025 while (!feof (dictstat_fp))
10026 {
10027 dictstat_t d;
10028
10029 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10030
10031 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10032
10033 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10034 {
10035 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10036
10037 return -1;
10038 }
10039 }
10040
10041 fclose (dictstat_fp);
10042 }
10043 }
10044 }
10045
10046 /**
10047 * potfile
10048 */
10049
10050 char potfile[256];
10051
10052 memset (potfile, 0, sizeof (potfile));
10053
10054 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10055
10056 data.pot_fp = NULL;
10057
10058 FILE *out_fp = NULL;
10059 FILE *pot_fp = NULL;
10060
10061 if (show == 1 || left == 1)
10062 {
10063 pot_fp = fopen (potfile, "rb");
10064
10065 if (pot_fp == NULL)
10066 {
10067 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10068
10069 return (-1);
10070 }
10071
10072 if (outfile != NULL)
10073 {
10074 if ((out_fp = fopen (outfile, "ab")) == NULL)
10075 {
10076 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10077
10078 fclose (pot_fp);
10079
10080 return (-1);
10081 }
10082 }
10083 else
10084 {
10085 out_fp = stdout;
10086 }
10087 }
10088 else
10089 {
10090 if (potfile_disable == 0)
10091 {
10092 pot_fp = fopen (potfile, "ab");
10093
10094 if (pot_fp == NULL)
10095 {
10096 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10097
10098 return (-1);
10099 }
10100
10101 data.pot_fp = pot_fp;
10102 }
10103 }
10104
10105 pot_t *pot = NULL;
10106
10107 uint pot_cnt = 0;
10108 uint pot_avail = 0;
10109
10110 if (show == 1 || left == 1)
10111 {
10112 SUPPRESS_OUTPUT = 1;
10113
10114 pot_avail = count_lines (pot_fp);
10115
10116 rewind (pot_fp);
10117
10118 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10119
10120 uint pot_hashes_avail = 0;
10121
10122 uint line_num = 0;
10123
10124 while (!feof (pot_fp))
10125 {
10126 line_num++;
10127
10128 char line_buf[BUFSIZ];
10129
10130 int line_len = fgetl (pot_fp, line_buf);
10131
10132 if (line_len == 0) continue;
10133
10134 char *plain_buf = line_buf + line_len;
10135
10136 pot_t *pot_ptr = &pot[pot_cnt];
10137
10138 hash_t *hashes_buf = &pot_ptr->hash;
10139
10140 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10141 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10142
10143 if (pot_cnt == pot_hashes_avail)
10144 {
10145 uint pos = 0;
10146
10147 for (pos = 0; pos < INCR_POT; pos++)
10148 {
10149 if ((pot_cnt + pos) >= pot_avail) break;
10150
10151 pot_t *tmp_pot = &pot[pot_cnt + pos];
10152
10153 hash_t *tmp_hash = &tmp_pot->hash;
10154
10155 tmp_hash->digest = mymalloc (dgst_size);
10156
10157 if (isSalted)
10158 {
10159 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10160 }
10161
10162 if (esalt_size)
10163 {
10164 tmp_hash->esalt = mymalloc (esalt_size);
10165 }
10166
10167 pot_hashes_avail++;
10168 }
10169 }
10170
10171 int plain_len = 0;
10172
10173 int parser_status;
10174
10175 int iter = MAX_CUT_TRIES;
10176
10177 do
10178 {
10179 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10180 {
10181 if (line_buf[i] == ':')
10182 {
10183 line_len--;
10184
10185 break;
10186 }
10187 }
10188
10189 if (data.hash_mode != 2500)
10190 {
10191 parser_status = parse_func (line_buf, line_len, hashes_buf);
10192 }
10193 else
10194 {
10195 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10196
10197 if (line_len > max_salt_size)
10198 {
10199 parser_status = PARSER_GLOBAL_LENGTH;
10200 }
10201 else
10202 {
10203 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10204
10205 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10206
10207 hashes_buf->salt->salt_len = line_len;
10208
10209 parser_status = PARSER_OK;
10210 }
10211 }
10212
10213 // if NOT parsed without error, we add the ":" to the plain
10214
10215 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10216 {
10217 plain_len++;
10218 plain_buf--;
10219 }
10220
10221 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10222
10223 if (parser_status < PARSER_GLOBAL_ZERO)
10224 {
10225 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10226
10227 continue;
10228 }
10229
10230 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10231
10232 pot_ptr->plain_len = plain_len;
10233
10234 pot_cnt++;
10235 }
10236
10237 fclose (pot_fp);
10238
10239 SUPPRESS_OUTPUT = 0;
10240
10241 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10242 }
10243
10244 /**
10245 * kernel accel and loops auto adjustment
10246 */
10247
10248 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10249 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10250
10251 if (workload_profile == 1)
10252 {
10253 kernel_loops /= 8;
10254 kernel_accel /= 4;
10255
10256 if (kernel_loops == 0) kernel_loops = 8;
10257 if (kernel_accel == 0) kernel_accel = 2;
10258 }
10259 else if (workload_profile == 3)
10260 {
10261 kernel_loops *= 8;
10262 kernel_accel *= 4;
10263
10264 if (kernel_loops > 1024) kernel_loops = 1024;
10265 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10266 }
10267
10268 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10269
10270 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10271 {
10272 kernel_loops = 1024;
10273 }
10274
10275 if (hash_mode == 12500)
10276 {
10277 kernel_loops = ROUNDS_RAR3 / 16;
10278 }
10279
10280 data.kernel_accel = kernel_accel;
10281 data.kernel_loops = kernel_loops;
10282
10283 /**
10284 * word len
10285 */
10286
10287 uint pw_min = PW_MIN;
10288 uint pw_max = PW_MAX;
10289
10290 switch (hash_mode)
10291 {
10292 case 400: if (pw_max > 40) pw_max = 40;
10293 break;
10294 case 500: if (pw_max > 16) pw_max = 16;
10295 break;
10296 case 1500: if (pw_max > 8) pw_max = 8;
10297 break;
10298 case 1600: if (pw_max > 16) pw_max = 16;
10299 break;
10300 case 1800: if (pw_max > 16) pw_max = 16;
10301 break;
10302 case 2100: if (pw_max > 16) pw_max = 16;
10303 break;
10304 case 2500: if (pw_min < 8) pw_min = 8;
10305 break;
10306 case 3000: if (pw_max > 7) pw_max = 7;
10307 break;
10308 case 5200: if (pw_max > 24) pw_max = 24;
10309 break;
10310 case 5800: if (pw_max > 16) pw_max = 16;
10311 break;
10312 case 6300: if (pw_max > 16) pw_max = 16;
10313 break;
10314 case 7400: if (pw_max > 16) pw_max = 16;
10315 break;
10316 case 7900: if (pw_max > 48) pw_max = 48;
10317 break;
10318 case 8500: if (pw_max > 8) pw_max = 8;
10319 break;
10320 case 8600: if (pw_max > 16) pw_max = 16;
10321 break;
10322 case 9710: pw_min = 5;
10323 pw_max = 5;
10324 break;
10325 case 9810: pw_min = 5;
10326 pw_max = 5;
10327 break;
10328 case 10410: pw_min = 5;
10329 pw_max = 5;
10330 break;
10331 case 10300: if (pw_max < 3) pw_min = 3;
10332 if (pw_max > 40) pw_max = 40;
10333 break;
10334 case 10500: if (pw_max < 3) pw_min = 3;
10335 if (pw_max > 40) pw_max = 40;
10336 break;
10337 case 10700: if (pw_max > 16) pw_max = 16;
10338 break;
10339 case 11300: if (pw_max > 40) pw_max = 40;
10340 break;
10341 case 12500: if (pw_max > 20) pw_max = 20;
10342 break;
10343 case 12800: if (pw_max > 24) pw_max = 24;
10344 break;
10345 }
10346
10347 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10348 {
10349 switch (attack_kern)
10350 {
10351 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10352 break;
10353 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10354 break;
10355 }
10356 }
10357
10358 /**
10359 * charsets : keep them together for more easy maintainnce
10360 */
10361
10362 cs_t mp_sys[6];
10363 cs_t mp_usr[4];
10364
10365 memset (mp_sys, 0, sizeof (mp_sys));
10366 memset (mp_usr, 0, sizeof (mp_usr));
10367
10368 mp_setup_sys (mp_sys);
10369
10370 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10371 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10372 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10373 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10374
10375 /**
10376 * load hashes, part I: find input mode, count hashes
10377 */
10378
10379 uint hashlist_mode = 0;
10380 uint hashlist_format = HLFMT_HASHCAT;
10381
10382 uint hashes_avail = 0;
10383
10384 if (benchmark == 0)
10385 {
10386 struct stat f;
10387
10388 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10389
10390 if ((hash_mode == 2500) ||
10391 (hash_mode == 5200) ||
10392 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10393 (hash_mode == 9000))
10394 {
10395 hashlist_mode = HL_MODE_ARG;
10396
10397 char *hashfile = myargv[optind];
10398
10399 data.hashfile = hashfile;
10400
10401 logfile_top_var_string ("target", hashfile);
10402 }
10403
10404 if (hashlist_mode == HL_MODE_ARG)
10405 {
10406 if (hash_mode == 2500)
10407 {
10408 struct stat st;
10409
10410 if (stat (data.hashfile, &st) == -1)
10411 {
10412 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10413
10414 return (-1);
10415 }
10416
10417 hashes_avail = st.st_size / sizeof (hccap_t);
10418 }
10419 else
10420 {
10421 hashes_avail = 1;
10422 }
10423 }
10424 else if (hashlist_mode == HL_MODE_FILE)
10425 {
10426 char *hashfile = myargv[optind];
10427
10428 data.hashfile = hashfile;
10429
10430 logfile_top_var_string ("target", hashfile);
10431
10432 FILE *fp = NULL;
10433
10434 if ((fp = fopen (hashfile, "rb")) == NULL)
10435 {
10436 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10437
10438 return (-1);
10439 }
10440
10441 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10442
10443 hashes_avail = count_lines (fp);
10444
10445 rewind (fp);
10446
10447 if (hashes_avail == 0)
10448 {
10449 log_error ("ERROR: hashfile is empty or corrupt");
10450
10451 fclose (fp);
10452
10453 return (-1);
10454 }
10455
10456 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10457
10458 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10459 {
10460 log_error ("ERROR: remove not supported in native hashfile-format mode");
10461
10462 fclose (fp);
10463
10464 return (-1);
10465 }
10466
10467 fclose (fp);
10468 }
10469 }
10470 else
10471 {
10472 hashlist_mode = HL_MODE_ARG;
10473
10474 hashes_avail = 1;
10475 }
10476
10477 if (hash_mode == 3000) hashes_avail *= 2;
10478
10479 data.hashlist_mode = hashlist_mode;
10480 data.hashlist_format = hashlist_format;
10481
10482 logfile_top_uint (hashlist_mode);
10483 logfile_top_uint (hashlist_format);
10484
10485 /**
10486 * load hashes, part II: allocate required memory, set pointers
10487 */
10488
10489 hash_t *hashes_buf = NULL;
10490 void *digests_buf = NULL;
10491 salt_t *salts_buf = NULL;
10492 void *esalts_buf = NULL;
10493
10494 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10495
10496 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10497
10498 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10499 {
10500 uint32_t hash_pos;
10501
10502 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10503 {
10504 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10505
10506 hashes_buf[hash_pos].hash_info = hash_info;
10507
10508 if (username && (remove || show || left))
10509 {
10510 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10511 }
10512
10513 if (benchmark)
10514 {
10515 hash_info->orighash = (char *) mymalloc (256);
10516 }
10517 }
10518 }
10519
10520 if (isSalted)
10521 {
10522 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10523
10524 if (esalt_size)
10525 {
10526 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10527 }
10528 }
10529 else
10530 {
10531 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10532 }
10533
10534 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10535 {
10536 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10537
10538 if (isSalted)
10539 {
10540 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10541
10542 if (esalt_size)
10543 {
10544 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10545 }
10546 }
10547 else
10548 {
10549 hashes_buf[hash_pos].salt = &salts_buf[0];
10550 }
10551 }
10552
10553 /**
10554 * load hashes, part III: parse hashes or generate them if benchmark
10555 */
10556
10557 uint hashes_cnt = 0;
10558
10559 if (benchmark == 0)
10560 {
10561 if (keyspace == 1)
10562 {
10563 // useless to read hash file for keyspace, cheat a little bit w/ optind
10564 }
10565 else if (hashes_avail == 0)
10566 {
10567 }
10568 else if (hashlist_mode == HL_MODE_ARG)
10569 {
10570 char *input_buf = myargv[optind];
10571
10572 uint input_len = strlen (input_buf);
10573
10574 logfile_top_var_string ("target", input_buf);
10575
10576 char *hash_buf = NULL;
10577 int hash_len = 0;
10578
10579 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10580
10581 if (hash_len)
10582 {
10583 if (opts_type & OPTS_TYPE_HASH_COPY)
10584 {
10585 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10586
10587 hash_info_tmp->orighash = mystrdup (hash_buf);
10588 }
10589
10590 if (isSalted)
10591 {
10592 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10593 }
10594
10595 int parser_status = PARSER_OK;
10596
10597 if (hash_mode == 2500)
10598 {
10599 if (hash_len == 0)
10600 {
10601 log_error ("ERROR: hccap file not specified");
10602
10603 return (-1);
10604 }
10605
10606 hashlist_mode = HL_MODE_FILE;
10607
10608 data.hashlist_mode = hashlist_mode;
10609
10610 FILE *fp = fopen (hash_buf, "rb");
10611
10612 if (fp == NULL)
10613 {
10614 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10615
10616 return (-1);
10617 }
10618
10619 if (hashes_avail < 1)
10620 {
10621 log_error ("ERROR: hccap file is empty or corrupt");
10622
10623 fclose (fp);
10624
10625 return (-1);
10626 }
10627
10628 uint hccap_size = sizeof (hccap_t);
10629
10630 char in[hccap_size];
10631
10632 while (!feof (fp))
10633 {
10634 int n = fread (&in, hccap_size, 1, fp);
10635
10636 if (n != 1)
10637 {
10638 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10639
10640 break;
10641 }
10642
10643 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10644
10645 if (parser_status != PARSER_OK)
10646 {
10647 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10648
10649 continue;
10650 }
10651
10652 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10653
10654 if ((show == 1) || (left == 1))
10655 {
10656 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10657
10658 char *salt_ptr = (char *) tmp_salt->salt_buf;
10659
10660 int cur_pos = tmp_salt->salt_len;
10661 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10662
10663 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10664
10665 unsigned char *pke_ptr = (unsigned char *) wpa->pke;
10666
10667 // do the appending task
10668
10669 snprintf (salt_ptr + cur_pos,
10670 rem_len,
10671 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10672 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10673 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10674
10675
10676 // memset () the remaining part of the salt
10677
10678 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10679 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10680
10681 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10682
10683 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10684 }
10685
10686 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);
10687 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);
10688
10689 hashes_cnt++;
10690 }
10691
10692 fclose (fp);
10693 }
10694 else if (hash_mode == 3000)
10695 {
10696 if (hash_len == 32)
10697 {
10698 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10699
10700 hash_t *lm_hash_left = NULL;
10701
10702 if (parser_status == PARSER_OK)
10703 {
10704 lm_hash_left = &hashes_buf[hashes_cnt];
10705
10706 hashes_cnt++;
10707 }
10708 else
10709 {
10710 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10711 }
10712
10713
10714 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10715
10716 hash_t *lm_hash_right = NULL;
10717
10718 if (parser_status == PARSER_OK)
10719 {
10720 lm_hash_right = &hashes_buf[hashes_cnt];
10721
10722 hashes_cnt++;
10723 }
10724 else
10725 {
10726 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10727 }
10728
10729 // show / left
10730
10731 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10732 {
10733 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);
10734 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);
10735 }
10736 }
10737 else
10738 {
10739 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10740
10741 if (parser_status == PARSER_OK)
10742 {
10743 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10744 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10745 }
10746
10747 if (parser_status == PARSER_OK)
10748 {
10749 hashes_cnt++;
10750 }
10751 else
10752 {
10753 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10754 }
10755 }
10756 }
10757 else
10758 {
10759 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10760
10761 if (parser_status == PARSER_OK)
10762 {
10763 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10764 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10765 }
10766
10767 if (parser_status == PARSER_OK)
10768 {
10769 hashes_cnt++;
10770 }
10771 else
10772 {
10773 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10774 }
10775 }
10776 }
10777 }
10778 else if (hashlist_mode == HL_MODE_FILE)
10779 {
10780 char *hashfile = data.hashfile;
10781
10782 FILE *fp;
10783
10784 if ((fp = fopen (hashfile, "rb")) == NULL)
10785 {
10786 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10787
10788 return (-1);
10789 }
10790
10791 uint line_num = 0;
10792
10793 while (!feof (fp))
10794 {
10795 line_num++;
10796
10797 char line_buf[BUFSIZ];
10798
10799 int line_len = fgetl (fp, line_buf);
10800
10801 if (line_len == 0) continue;
10802
10803 char *hash_buf = NULL;
10804 int hash_len = 0;
10805
10806 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10807
10808 if (username)
10809 {
10810 char *user_buf = NULL;
10811 int user_len = 0;
10812
10813 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10814
10815 if (remove || show)
10816 {
10817 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10818
10819 *user = (user_t *) malloc (sizeof (user_t));
10820
10821 user_t *user_ptr = *user;
10822
10823 if (user_buf != NULL)
10824 {
10825 user_ptr->user_name = mystrdup (user_buf);
10826 }
10827 else
10828 {
10829 user_ptr->user_name = mystrdup ("");
10830 }
10831
10832 user_ptr->user_len = user_len;
10833 }
10834 }
10835
10836 if (opts_type & OPTS_TYPE_HASH_COPY)
10837 {
10838 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10839
10840 hash_info_tmp->orighash = mystrdup (hash_buf);
10841 }
10842
10843 if (isSalted)
10844 {
10845 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10846 }
10847
10848 if (hash_mode == 3000)
10849 {
10850 if (hash_len == 32)
10851 {
10852 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10853
10854 if (parser_status < PARSER_GLOBAL_ZERO)
10855 {
10856 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10857
10858 continue;
10859 }
10860
10861 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10862
10863 hashes_cnt++;
10864
10865 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10866
10867 if (parser_status < PARSER_GLOBAL_ZERO)
10868 {
10869 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10870
10871 continue;
10872 }
10873
10874 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10875
10876 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);
10877
10878 hashes_cnt++;
10879
10880 // show / left
10881
10882 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);
10883 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);
10884 }
10885 else
10886 {
10887 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10888
10889 if (parser_status < PARSER_GLOBAL_ZERO)
10890 {
10891 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10892
10893 continue;
10894 }
10895
10896 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);
10897
10898 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10899 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10900
10901 hashes_cnt++;
10902 }
10903 }
10904 else
10905 {
10906 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10907
10908 if (parser_status < PARSER_GLOBAL_ZERO)
10909 {
10910 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10911
10912 continue;
10913 }
10914
10915 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);
10916
10917 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10918 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10919
10920 hashes_cnt++;
10921 }
10922 }
10923
10924 fclose (fp);
10925
10926 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10927
10928 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10929 }
10930 }
10931 else
10932 {
10933 if (isSalted)
10934 {
10935 hashes_buf[0].salt->salt_len = 8;
10936
10937 // special salt handling
10938
10939 switch (hash_mode)
10940 {
10941 case 1500: hashes_buf[0].salt->salt_len = 2;
10942 break;
10943 case 1731: hashes_buf[0].salt->salt_len = 4;
10944 break;
10945 case 2410: hashes_buf[0].salt->salt_len = 4;
10946 break;
10947 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10948 break;
10949 case 3100: hashes_buf[0].salt->salt_len = 1;
10950 break;
10951 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10952 break;
10953 case 5800: hashes_buf[0].salt->salt_len = 16;
10954 break;
10955 case 6800: hashes_buf[0].salt->salt_len = 32;
10956 break;
10957 case 8400: hashes_buf[0].salt->salt_len = 40;
10958 break;
10959 case 8800: hashes_buf[0].salt->salt_len = 16;
10960 break;
10961 case 8900: hashes_buf[0].salt->salt_len = 16;
10962 hashes_buf[0].salt->scrypt_N = 1024;
10963 hashes_buf[0].salt->scrypt_r = 1;
10964 hashes_buf[0].salt->scrypt_p = 1;
10965 break;
10966 case 9100: hashes_buf[0].salt->salt_len = 16;
10967 break;
10968 case 9300: hashes_buf[0].salt->salt_len = 14;
10969 hashes_buf[0].salt->scrypt_N = 16384;
10970 hashes_buf[0].salt->scrypt_r = 1;
10971 hashes_buf[0].salt->scrypt_p = 1;
10972 break;
10973 case 9400: hashes_buf[0].salt->salt_len = 16;
10974 break;
10975 case 9500: hashes_buf[0].salt->salt_len = 16;
10976 break;
10977 case 9600: hashes_buf[0].salt->salt_len = 16;
10978 break;
10979 case 9700: hashes_buf[0].salt->salt_len = 16;
10980 break;
10981 case 9710: hashes_buf[0].salt->salt_len = 16;
10982 break;
10983 case 9720: hashes_buf[0].salt->salt_len = 16;
10984 break;
10985 case 9800: hashes_buf[0].salt->salt_len = 16;
10986 break;
10987 case 9810: hashes_buf[0].salt->salt_len = 16;
10988 break;
10989 case 9820: hashes_buf[0].salt->salt_len = 16;
10990 break;
10991 case 10300: hashes_buf[0].salt->salt_len = 12;
10992 break;
10993 case 11500: hashes_buf[0].salt->salt_len = 4;
10994 break;
10995 case 11600: hashes_buf[0].salt->salt_len = 4;
10996 break;
10997 case 12400: hashes_buf[0].salt->salt_len = 4;
10998 break;
10999 case 12500: hashes_buf[0].salt->salt_len = 8;
11000 break;
11001 case 12600: hashes_buf[0].salt->salt_len = 64;
11002 break;
11003 }
11004
11005 // special esalt handling
11006
11007 switch (hash_mode)
11008 {
11009 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11010 break;
11011 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11012 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11013 break;
11014 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11015 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11016 break;
11017 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11018 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11019 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11020 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11021 break;
11022 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11023 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11024 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11025 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11026 break;
11027 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11028 break;
11029 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11030 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11031 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11032 break;
11033 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11034 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11035 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11036 break;
11037 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11038 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11039 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11040 break;
11041 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11042 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11043 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11044 break;
11045 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11046 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11047 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11048 break;
11049 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11050 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11051 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11052 break;
11053 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11054 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11055 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11056 break;
11057 }
11058 }
11059
11060 // set hashfile
11061
11062 switch (hash_mode)
11063 {
11064 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11065 break;
11066 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11067 break;
11068 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11069 break;
11070 case 6211:
11071 case 6212:
11072 case 6213:
11073 case 6221:
11074 case 6222:
11075 case 6223:
11076 case 6231:
11077 case 6232:
11078 case 6233:
11079 case 6241:
11080 case 6242:
11081 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11082 break;
11083 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11084 break;
11085 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11086 break;
11087 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11088 break;
11089 }
11090
11091 // set default iterations
11092
11093 switch (hash_mode)
11094 {
11095 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11096 break;
11097 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11098 break;
11099 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11100 break;
11101 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11102 break;
11103 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11104 break;
11105 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11106 break;
11107 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11108 break;
11109 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11110 break;
11111 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11112 break;
11113 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11114 break;
11115 case 6211:
11116 case 6212:
11117 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11118 break;
11119 case 6221:
11120 case 6222:
11121 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11122 break;
11123 case 6231:
11124 case 6232:
11125 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11126 break;
11127 case 6241:
11128 case 6242:
11129 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11130 break;
11131 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11132 break;
11133 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11134 break;
11135 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11136 break;
11137 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11138 break;
11139 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11140 break;
11141 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11142 break;
11143 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11144 break;
11145 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11146 break;
11147 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11148 break;
11149 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11150 break;
11151 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11152 break;
11153 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11154 break;
11155 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11156 break;
11157 case 8900: hashes_buf[0].salt->salt_iter = 1;
11158 break;
11159 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11160 break;
11161 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11162 break;
11163 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11164 break;
11165 case 9300: hashes_buf[0].salt->salt_iter = 1;
11166 break;
11167 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11168 break;
11169 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11170 break;
11171 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11172 break;
11173 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11174 break;
11175 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11176 break;
11177 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11178 break;
11179 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11180 break;
11181 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11182 break;
11183 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11184 break;
11185 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11186 break;
11187 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11188 break;
11189 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11190 break;
11191 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11192 break;
11193 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11194 break;
11195 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11196 break;
11197 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11198 break;
11199 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11200 break;
11201 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11202 break;
11203 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11204 break;
11205 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11206 break;
11207 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11208 break;
11209 }
11210
11211 // set special tuning for benchmark-mode 1
11212
11213 if (benchmark_mode == 1)
11214 {
11215 kernel_loops *= 8;
11216 kernel_accel *= 4;
11217
11218 switch (hash_mode)
11219 {
11220 case 400: kernel_loops = ROUNDS_PHPASS;
11221 kernel_accel = 32;
11222 break;
11223 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11224 kernel_accel = 32;
11225 break;
11226 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11227 kernel_accel = 32;
11228 break;
11229 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11230 kernel_accel = 32;
11231 break;
11232 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11233 kernel_accel = 16;
11234 break;
11235 case 2100: kernel_loops = ROUNDS_DCC2;
11236 kernel_accel = 16;
11237 break;
11238 case 2500: kernel_loops = ROUNDS_WPA2;
11239 kernel_accel = 32;
11240 break;
11241 case 3200: kernel_loops = ROUNDS_BCRYPT;
11242 kernel_accel = 8;
11243 break;
11244 case 5200: kernel_loops = ROUNDS_PSAFE3;
11245 kernel_accel = 16;
11246 break;
11247 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11248 kernel_accel = 16;
11249 break;
11250 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11251 kernel_accel = 64;
11252 break;
11253 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11254 kernel_accel = 32;
11255 break;
11256 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11257 kernel_accel = 32;
11258 break;
11259 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11260 kernel_accel = 8;
11261 break;
11262 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11263 kernel_accel = 8;
11264 break;
11265 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11266 kernel_accel = 8;
11267 break;
11268 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11269 kernel_accel = 8;
11270 break;
11271 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11272 kernel_accel = 8;
11273 break;
11274 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11275 kernel_accel = 8;
11276 break;
11277 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11278 kernel_accel = 128;
11279 break;
11280 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11281 kernel_accel = 64;
11282 break;
11283 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11284 kernel_accel = 64;
11285 break;
11286 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11287 kernel_accel = 32;
11288 break;
11289 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11290 kernel_accel = 128;
11291 break;
11292 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11293 kernel_accel = 128;
11294 break;
11295 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11296 kernel_accel = 32;
11297 break;
11298 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11299 kernel_accel = 64;
11300 break;
11301 case 6800: kernel_loops = ROUNDS_LASTPASS;
11302 kernel_accel = 64;
11303 break;
11304 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11305 kernel_accel = 8;
11306 break;
11307 case 7200: kernel_loops = ROUNDS_GRUB;
11308 kernel_accel = 16;
11309 break;
11310 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11311 kernel_accel = 8;
11312 break;
11313 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11314 kernel_accel = 8;
11315 break;
11316 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11317 kernel_accel = 8;
11318 break;
11319 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11320 kernel_accel = 32;
11321 break;
11322 case 8900: kernel_loops = 1;
11323 kernel_accel = 64;
11324 break;
11325 case 9000: kernel_loops = ROUNDS_PSAFE2;
11326 kernel_accel = 16;
11327 break;
11328 case 9100: kernel_loops = ROUNDS_LOTUS8;
11329 kernel_accel = 64;
11330 break;
11331 case 9200: kernel_loops = ROUNDS_CISCO8;
11332 kernel_accel = 8;
11333 break;
11334 case 9300: kernel_loops = 1;
11335 kernel_accel = 4;
11336 break;
11337 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11338 kernel_accel = 32;
11339 break;
11340 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11341 kernel_accel = 32;
11342 break;
11343 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11344 kernel_accel = 8;
11345 break;
11346 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11347 kernel_accel = 8;
11348 break;
11349 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11350 kernel_accel = 16;
11351 break;
11352 case 10500: kernel_loops = ROUNDS_PDF14;
11353 kernel_accel = 256;
11354 break;
11355 case 10700: kernel_loops = ROUNDS_PDF17L8;
11356 kernel_accel = 8;
11357 break;
11358 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11359 kernel_accel = 8;
11360 break;
11361 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11362 kernel_accel = 8;
11363 break;
11364 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11365 kernel_accel = 8;
11366 break;
11367 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11368 kernel_accel = 8;
11369 break;
11370 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11371 kernel_accel = 8;
11372 break;
11373 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11374 kernel_accel = 8;
11375 break;
11376 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11377 kernel_accel = 8;
11378 break;
11379 case 12300: kernel_loops = ROUNDS_ORACLET;
11380 kernel_accel = 8;
11381 break;
11382 case 12500: kernel_loops = ROUNDS_RAR3;
11383 kernel_accel = 32;
11384 break;
11385 case 12700: kernel_loops = ROUNDS_MYWALLET;
11386 kernel_accel = 512;
11387 break;
11388 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11389 kernel_accel = 512;
11390 break;
11391 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11392 kernel_accel = 8;
11393 break;
11394 case 13000: kernel_loops = ROUNDS_RAR5;
11395 kernel_accel = 8;
11396 break;
11397 }
11398
11399 // some algorithm collide too fast, make that impossible
11400
11401 switch (hash_mode)
11402 {
11403 case 11500: ((uint *) digests_buf)[1] = 1;
11404 break;
11405 }
11406
11407 if (kernel_loops > 1024) kernel_loops = 1024;
11408 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11409 }
11410
11411 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11412 {
11413 kernel_loops = 1024;
11414 }
11415
11416 if (hash_mode == 12500)
11417 {
11418 kernel_loops = ROUNDS_RAR3 / 16;
11419 }
11420
11421 data.kernel_accel = kernel_accel;
11422 data.kernel_loops = kernel_loops;
11423
11424 hashes_cnt = 1;
11425 }
11426
11427 if (show == 1 || left == 1)
11428 {
11429 for (uint i = 0; i < pot_cnt; i++)
11430 {
11431 pot_t *pot_ptr = &pot[i];
11432
11433 hash_t *hashes_buf = &pot_ptr->hash;
11434
11435 local_free (hashes_buf->digest);
11436
11437 if (isSalted)
11438 {
11439 local_free (hashes_buf->salt);
11440 }
11441 }
11442
11443 local_free (pot);
11444
11445 if (data.quiet == 0) log_info_nn ("");
11446
11447 return (0);
11448 }
11449
11450 if (keyspace == 0)
11451 {
11452 if (hashes_cnt == 0)
11453 {
11454 log_error ("ERROR: No hashes loaded");
11455
11456 return (-1);
11457 }
11458 }
11459
11460 /**
11461 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11462 */
11463
11464 if (data.outfile != NULL)
11465 {
11466 if (data.hashfile != NULL)
11467 {
11468 #ifdef _POSIX
11469 struct stat tmpstat_outfile;
11470 struct stat tmpstat_hashfile;
11471 #endif
11472
11473 #ifdef _WIN
11474 struct stat64 tmpstat_outfile;
11475 struct stat64 tmpstat_hashfile;
11476 #endif
11477
11478 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11479
11480 if (tmp_outfile_fp)
11481 {
11482 #ifdef _POSIX
11483 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11484 #endif
11485
11486 #ifdef _WIN
11487 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11488 #endif
11489
11490 fclose (tmp_outfile_fp);
11491 }
11492
11493 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11494
11495 if (tmp_hashfile_fp)
11496 {
11497 #ifdef _POSIX
11498 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11499 #endif
11500
11501 #ifdef _WIN
11502 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11503 #endif
11504
11505 fclose (tmp_hashfile_fp);
11506 }
11507
11508 if (tmp_outfile_fp && tmp_outfile_fp)
11509 {
11510 tmpstat_outfile.st_mode = 0;
11511 tmpstat_outfile.st_nlink = 0;
11512 tmpstat_outfile.st_uid = 0;
11513 tmpstat_outfile.st_gid = 0;
11514 tmpstat_outfile.st_rdev = 0;
11515 tmpstat_outfile.st_atime = 0;
11516
11517 tmpstat_hashfile.st_mode = 0;
11518 tmpstat_hashfile.st_nlink = 0;
11519 tmpstat_hashfile.st_uid = 0;
11520 tmpstat_hashfile.st_gid = 0;
11521 tmpstat_hashfile.st_rdev = 0;
11522 tmpstat_hashfile.st_atime = 0;
11523
11524 #ifdef _POSIX
11525 tmpstat_outfile.st_blksize = 0;
11526 tmpstat_outfile.st_blocks = 0;
11527
11528 tmpstat_hashfile.st_blksize = 0;
11529 tmpstat_hashfile.st_blocks = 0;
11530 #endif
11531
11532 #ifdef _POSIX
11533 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11534 {
11535 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11536
11537 return (-1);
11538 }
11539 #endif
11540
11541 #ifdef _WIN
11542 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11543 {
11544 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11545
11546 return (-1);
11547 }
11548 #endif
11549 }
11550 }
11551 }
11552
11553 /**
11554 * Remove duplicates
11555 */
11556
11557 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11558
11559 if (isSalted)
11560 {
11561 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11562 }
11563 else
11564 {
11565 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11566 }
11567
11568 uint hashes_cnt_orig = hashes_cnt;
11569
11570 hashes_cnt = 1;
11571
11572 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11573 {
11574 if (isSalted)
11575 {
11576 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11577 {
11578 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11579 }
11580 }
11581 else
11582 {
11583 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11584 }
11585
11586 if (hashes_pos > hashes_cnt)
11587 {
11588 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11589 }
11590
11591 hashes_cnt++;
11592 }
11593
11594 /**
11595 * Potfile removes
11596 */
11597
11598 uint potfile_remove_cracks = 0;
11599
11600 if (potfile_disable == 0)
11601 {
11602 hash_t hash_buf;
11603
11604 hash_buf.digest = mymalloc (dgst_size);
11605 hash_buf.salt = NULL;
11606 hash_buf.esalt = NULL;
11607 hash_buf.hash_info = NULL;
11608 hash_buf.cracked = 0;
11609
11610 if (isSalted)
11611 {
11612 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11613 }
11614
11615 if (esalt_size)
11616 {
11617 hash_buf.esalt = mymalloc (esalt_size);
11618 }
11619
11620 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11621
11622 // no solution for these special hash types (for instane because they use hashfile in output etc)
11623 if ((hash_mode != 5200) &&
11624 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11625 (hash_mode != 9000))
11626 {
11627 FILE *fp = fopen (potfile, "rb");
11628
11629 if (fp != NULL)
11630 {
11631 while (!feof (fp))
11632 {
11633 char line_buf[BUFSIZ];
11634
11635 memset (line_buf, 0, BUFSIZ);
11636
11637 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11638
11639 if (ptr == NULL) break;
11640
11641 int line_len = strlen (line_buf);
11642
11643 if (line_len == 0) continue;
11644
11645 int iter = MAX_CUT_TRIES;
11646
11647 for (int i = line_len - 1; i && iter; i--, line_len--)
11648 {
11649 if (line_buf[i] != ':') continue;
11650
11651 if (isSalted)
11652 {
11653 memset (hash_buf.salt, 0, sizeof (salt_t));
11654 }
11655
11656 hash_t *found = NULL;
11657
11658 if (hash_mode == 6800)
11659 {
11660 if (i < 48) // 48 = 12 * uint in salt_buf[]
11661 {
11662 // manipulate salt_buf
11663 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11664
11665 hash_buf.salt->salt_len = i;
11666
11667 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11668 }
11669 }
11670 else if (hash_mode == 2500)
11671 {
11672 if (i < 48) // 48 = 12 * uint in salt_buf[]
11673 {
11674 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11675 // manipulate salt_buf
11676
11677 // to be safe work with a copy (because of line_len loop, i etc)
11678
11679 char line_buf_cpy[BUFSIZ];
11680 memset (line_buf_cpy, 0, BUFSIZ);
11681
11682 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11683
11684 memcpy (line_buf_cpy, line_buf, i);
11685
11686 char *mac2_pos = strrchr (line_buf_cpy, ':');
11687
11688 if (mac2_pos == NULL) continue;
11689
11690 mac2_pos[0] = 0;
11691 mac2_pos++;
11692
11693 if (strlen (mac2_pos) != 12) continue;
11694
11695 char *mac1_pos = strrchr (line_buf_cpy, ':');
11696
11697 if (mac1_pos == NULL) continue;
11698
11699 mac1_pos[0] = 0;
11700 mac1_pos++;
11701
11702 if (strlen (mac1_pos) != 12) continue;
11703
11704 uint essid_length = mac1_pos - line_buf_cpy - 1;
11705
11706 // here we need the ESSID
11707 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11708
11709 hash_buf.salt->salt_len = essid_length;
11710
11711 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11712
11713 if (found)
11714 {
11715 wpa_t *wpa = (wpa_t *) found->esalt;
11716
11717 uint pke[25];
11718
11719 char *pke_ptr = (char *) pke;
11720
11721 for (uint i = 0; i < 25; i++)
11722 {
11723 pke[i] = byte_swap_32 (wpa->pke[i]);
11724 }
11725
11726 unsigned char mac1[6];
11727 unsigned char mac2[6];
11728
11729 memcpy (mac1, pke_ptr + 23, 6);
11730 memcpy (mac2, pke_ptr + 29, 6);
11731
11732 // compare hex string(s) vs binary MAC address(es)
11733
11734 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11735 {
11736 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
11737 {
11738 found = NULL;
11739 break;
11740 }
11741 }
11742
11743 // early skip ;)
11744 if (!found) continue;
11745
11746 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11747 {
11748 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
11749 {
11750 found = NULL;
11751 break;
11752 }
11753 }
11754 }
11755 }
11756 }
11757 else
11758 {
11759 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11760
11761 if (parser_status == PARSER_OK)
11762 {
11763 if (isSalted)
11764 {
11765 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11766 }
11767 else
11768 {
11769 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11770 }
11771 }
11772 }
11773
11774 if (found == NULL) continue;
11775
11776 if (!found->cracked) potfile_remove_cracks++;
11777
11778 found->cracked = 1;
11779
11780 if (found) break;
11781
11782 iter--;
11783 }
11784 }
11785
11786 fclose (fp);
11787 }
11788 }
11789
11790 if (esalt_size)
11791 {
11792 local_free (hash_buf.esalt);
11793 }
11794
11795 if (isSalted)
11796 {
11797 local_free (hash_buf.salt);
11798 }
11799
11800 local_free (hash_buf.digest);
11801 }
11802
11803 /**
11804 * Now generate all the buffers required for later
11805 */
11806
11807 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11808
11809 salt_t *salts_buf_new = NULL;
11810 void *esalts_buf_new = NULL;
11811
11812 if (isSalted)
11813 {
11814 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11815
11816 if (esalt_size)
11817 {
11818 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11819 }
11820 }
11821 else
11822 {
11823 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11824 }
11825
11826 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11827
11828 uint digests_cnt = hashes_cnt;
11829 uint digests_done = 0;
11830
11831 uint size_digests = digests_cnt * dgst_size;
11832 uint size_shown = digests_cnt * sizeof (uint);
11833
11834 uint *digests_shown = (uint *) mymalloc (size_shown);
11835 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11836
11837 uint salts_cnt = 0;
11838 uint salts_done = 0;
11839
11840 hashinfo_t **hash_info = NULL;
11841
11842 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11843 {
11844 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11845
11846 if (username && (remove || show))
11847 {
11848 uint user_pos;
11849
11850 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11851 {
11852 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11853
11854 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11855 }
11856 }
11857 }
11858
11859 uint *salts_shown = (uint *) mymalloc (size_shown);
11860
11861 salt_t *salt_buf;
11862
11863 {
11864 // copied from inner loop
11865
11866 salt_buf = &salts_buf_new[salts_cnt];
11867
11868 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11869
11870 if (esalt_size)
11871 {
11872 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11873 }
11874
11875 salt_buf->digests_cnt = 0;
11876 salt_buf->digests_done = 0;
11877 salt_buf->digests_offset = 0;
11878
11879 salts_cnt++;
11880 }
11881
11882 if (hashes_buf[0].cracked == 1)
11883 {
11884 digests_shown[0] = 1;
11885
11886 digests_done++;
11887
11888 salt_buf->digests_done++;
11889 }
11890
11891 salt_buf->digests_cnt++;
11892
11893 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11894
11895 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11896 {
11897 hash_info[0] = hashes_buf[0].hash_info;
11898 }
11899
11900 // copy from inner loop
11901
11902 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11903 {
11904 if (isSalted)
11905 {
11906 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11907 {
11908 salt_buf = &salts_buf_new[salts_cnt];
11909
11910 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11911
11912 if (esalt_size)
11913 {
11914 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11915 }
11916
11917 salt_buf->digests_cnt = 0;
11918 salt_buf->digests_done = 0;
11919 salt_buf->digests_offset = hashes_pos;
11920
11921 salts_cnt++;
11922 }
11923 }
11924
11925 if (hashes_buf[hashes_pos].cracked == 1)
11926 {
11927 digests_shown[hashes_pos] = 1;
11928
11929 digests_done++;
11930
11931 salt_buf->digests_done++;
11932 }
11933
11934 salt_buf->digests_cnt++;
11935
11936 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11937
11938 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11939 {
11940 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11941 }
11942 }
11943
11944 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11945 {
11946 salt_t *salt_buf = &salts_buf_new[salt_pos];
11947
11948 if (salt_buf->digests_done == salt_buf->digests_cnt)
11949 {
11950 salts_shown[salt_pos] = 1;
11951
11952 salts_done++;
11953 }
11954
11955 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11956 }
11957
11958 local_free (digests_buf);
11959 local_free (salts_buf);
11960 local_free (esalts_buf);
11961
11962 digests_buf = digests_buf_new;
11963 salts_buf = salts_buf_new;
11964 esalts_buf = esalts_buf_new;
11965
11966 local_free (hashes_buf);
11967
11968 /**
11969 * special modification not set from parser
11970 */
11971
11972 switch (hash_mode)
11973 {
11974 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11975 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11976 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11977 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11978 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11979 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11980 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11981 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11982 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11983 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11984 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11985 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11986 }
11987
11988 if (truecrypt_keyfiles)
11989 {
11990 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11991
11992 char *keyfiles = strdup (truecrypt_keyfiles);
11993
11994 char *keyfile = strtok (keyfiles, ",");
11995
11996 do
11997 {
11998 truecrypt_crc32 (keyfile, (unsigned char *) keyfile_buf);
11999
12000 } while ((keyfile = strtok (NULL, ",")) != NULL);
12001
12002 free (keyfiles);
12003 }
12004
12005 data.digests_cnt = digests_cnt;
12006 data.digests_done = digests_done;
12007 data.digests_buf = digests_buf;
12008 data.digests_shown = digests_shown;
12009 data.digests_shown_tmp = digests_shown_tmp;
12010
12011 data.salts_cnt = salts_cnt;
12012 data.salts_done = salts_done;
12013 data.salts_buf = salts_buf;
12014 data.salts_shown = salts_shown;
12015
12016 data.esalts_buf = esalts_buf;
12017 data.hash_info = hash_info;
12018
12019 /**
12020 * Automatic Optimizers
12021 */
12022
12023 if (salts_cnt == 1)
12024 opti_type |= OPTI_TYPE_SINGLE_SALT;
12025
12026 if (digests_cnt == 1)
12027 opti_type |= OPTI_TYPE_SINGLE_HASH;
12028
12029 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12030 opti_type |= OPTI_TYPE_NOT_ITERATED;
12031
12032 if (attack_mode == ATTACK_MODE_BF)
12033 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12034
12035 data.opti_type = opti_type;
12036
12037 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12038 {
12039 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12040 {
12041 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12042 {
12043 if (opts_type & OPTS_TYPE_ST_ADD80)
12044 {
12045 opts_type &= ~OPTS_TYPE_ST_ADD80;
12046 opts_type |= OPTS_TYPE_PT_ADD80;
12047 }
12048
12049 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12050 {
12051 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12052 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12053 }
12054
12055 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12056 {
12057 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12058 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12059 }
12060 }
12061 }
12062 }
12063
12064 /**
12065 * Some algorithm, like descrypt, can benefit from JIT compilation
12066 */
12067
12068 uint force_jit_compilation = 0;
12069
12070 if (hash_mode == 8900)
12071 {
12072 force_jit_compilation = 8900;
12073 }
12074 else if (hash_mode == 9300)
12075 {
12076 force_jit_compilation = 8900;
12077 }
12078 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12079 {
12080 force_jit_compilation = 1500;
12081 }
12082
12083 /**
12084 * generate bitmap tables
12085 */
12086
12087 const uint bitmap_shift1 = 5;
12088 const uint bitmap_shift2 = 13;
12089
12090 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12091
12092 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12093 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12094 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12095 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12096 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12097 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12098 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12099 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12100
12101 uint bitmap_bits;
12102 uint bitmap_nums;
12103 uint bitmap_mask;
12104 uint bitmap_size;
12105
12106 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12107 {
12108 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12109
12110 bitmap_nums = 1 << bitmap_bits;
12111
12112 bitmap_mask = bitmap_nums - 1;
12113
12114 bitmap_size = bitmap_nums * sizeof (uint);
12115
12116 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12117
12118 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;
12119 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;
12120
12121 break;
12122 }
12123
12124 bitmap_nums = 1 << bitmap_bits;
12125
12126 bitmap_mask = bitmap_nums - 1;
12127
12128 bitmap_size = bitmap_nums * sizeof (uint);
12129
12130 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);
12131 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);
12132
12133 /**
12134 * prepare quick rule
12135 */
12136
12137 data.rule_buf_l = rule_buf_l;
12138 data.rule_buf_r = rule_buf_r;
12139
12140 int rule_len_l = (int) strlen (rule_buf_l);
12141 int rule_len_r = (int) strlen (rule_buf_r);
12142
12143 data.rule_len_l = rule_len_l;
12144 data.rule_len_r = rule_len_r;
12145
12146 /**
12147 * load rules
12148 */
12149
12150 uint *all_kernel_rules_cnt = NULL;
12151
12152 kernel_rule_t **all_kernel_rules_buf = NULL;
12153
12154 if (rp_files_cnt)
12155 {
12156 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12157
12158 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12159 }
12160
12161 char rule_buf[BUFSIZ];
12162
12163 int rule_len = 0;
12164
12165 for (uint i = 0; i < rp_files_cnt; i++)
12166 {
12167 uint kernel_rules_avail = 0;
12168
12169 uint kernel_rules_cnt = 0;
12170
12171 kernel_rule_t *kernel_rules_buf = NULL;
12172
12173 char *rp_file = rp_files[i];
12174
12175 char in[BLOCK_SIZE];
12176 char out[BLOCK_SIZE];
12177
12178 FILE *fp = NULL;
12179
12180 uint rule_line = 0;
12181
12182 if ((fp = fopen (rp_file, "rb")) == NULL)
12183 {
12184 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12185
12186 return (-1);
12187 }
12188
12189 while (!feof (fp))
12190 {
12191 memset (rule_buf, 0, BUFSIZ);
12192
12193 rule_len = fgetl (fp, rule_buf);
12194
12195 rule_line++;
12196
12197 if (rule_len == 0) continue;
12198
12199 if (rule_buf[0] == '#') continue;
12200
12201 if (kernel_rules_avail == kernel_rules_cnt)
12202 {
12203 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12204
12205 kernel_rules_avail += INCR_RULES;
12206 }
12207
12208 memset (in, 0, BLOCK_SIZE);
12209 memset (out, 0, BLOCK_SIZE);
12210
12211 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12212
12213 if (result == -1)
12214 {
12215 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12216
12217 continue;
12218 }
12219
12220 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12221 {
12222 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12223
12224 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12225
12226 continue;
12227 }
12228
12229 /* its so slow
12230 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12231 {
12232 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12233
12234 continue;
12235 }
12236 */
12237
12238 kernel_rules_cnt++;
12239 }
12240
12241 fclose (fp);
12242
12243 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12244
12245 all_kernel_rules_buf[i] = kernel_rules_buf;
12246 }
12247
12248 /**
12249 * merge rules or automatic rule generator
12250 */
12251
12252 uint kernel_rules_cnt = 0;
12253
12254 kernel_rule_t *kernel_rules_buf = NULL;
12255
12256 if (attack_mode == ATTACK_MODE_STRAIGHT)
12257 {
12258 if (rp_files_cnt)
12259 {
12260 kernel_rules_cnt = 1;
12261
12262 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12263
12264 repeats[0] = kernel_rules_cnt;
12265
12266 for (uint i = 0; i < rp_files_cnt; i++)
12267 {
12268 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12269
12270 repeats[i + 1] = kernel_rules_cnt;
12271 }
12272
12273 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12274
12275 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12276
12277 for (uint i = 0; i < kernel_rules_cnt; i++)
12278 {
12279 uint out_pos = 0;
12280
12281 kernel_rule_t *out = &kernel_rules_buf[i];
12282
12283 for (uint j = 0; j < rp_files_cnt; j++)
12284 {
12285 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12286 uint in_pos;
12287
12288 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12289
12290 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12291 {
12292 if (out_pos == RULES_MAX - 1)
12293 {
12294 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12295
12296 break;
12297 }
12298
12299 out->cmds[out_pos] = in->cmds[in_pos];
12300 }
12301 }
12302 }
12303
12304 local_free (repeats);
12305 }
12306 else if (rp_gen)
12307 {
12308 uint kernel_rules_avail = 0;
12309
12310 while (kernel_rules_cnt < rp_gen)
12311 {
12312 if (kernel_rules_avail == kernel_rules_cnt)
12313 {
12314 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12315
12316 kernel_rules_avail += INCR_RULES;
12317 }
12318
12319 memset (rule_buf, 0, BLOCK_SIZE);
12320
12321 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12322
12323 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12324
12325 kernel_rules_cnt++;
12326 }
12327 }
12328 }
12329
12330 /**
12331 * generate NOP rules
12332 */
12333
12334 if (kernel_rules_cnt == 0)
12335 {
12336 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12337
12338 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12339
12340 kernel_rules_cnt++;
12341 }
12342
12343 data.kernel_rules_cnt = kernel_rules_cnt;
12344 data.kernel_rules_buf = kernel_rules_buf;
12345
12346 /**
12347 * platform
12348 */
12349
12350 cl_platform_id CL_platforms[CL_PLATFORMS_MAX];
12351
12352 uint CL_platforms_cnt = 0;
12353
12354 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, CL_platforms, &CL_platforms_cnt);
12355
12356 if (CL_platforms_cnt == 0)
12357 {
12358 log_error ("ERROR: No OpenCL compatible platform found");
12359
12360 return (-1);
12361 }
12362
12363 int CL_platform_sel = 1;
12364
12365 if (opencl_platform != NULL)
12366 {
12367 CL_platform_sel = atoi (opencl_platform);
12368 }
12369
12370 if (CL_platforms_cnt > 1)
12371 {
12372 if (opencl_platform == NULL)
12373 {
12374 log_error ("ERROR: Too many OpenCL compatible platforms found");
12375
12376 log_info ("Please select a single platform using the --opencl-platform option");
12377 log_info ("");
12378 log_info ("Available OpenCL platforms:");
12379 log_info ("");
12380
12381 for (uint i = 0; i < CL_platforms_cnt; i++)
12382 {
12383 char CL_platform_vendor[INFOSZ];
12384
12385 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12386
12387 hc_clGetPlatformInfo (CL_platforms[i], CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12388
12389 log_info ("* %d = %s", i + 1, CL_platform_vendor);
12390 }
12391
12392 log_info ("");
12393
12394 return (-1);
12395 }
12396 else
12397 {
12398 if (CL_platform_sel < 1)
12399 {
12400 log_error ("ERROR: --opencl-platform < 1");
12401
12402 return (-1);
12403 }
12404
12405 if (CL_platform_sel > (int) CL_platforms_cnt)
12406 {
12407 log_error ("ERROR: invalid OpenCL platforms selected");
12408
12409 return (-1);
12410 }
12411 }
12412 }
12413 else
12414 {
12415 if (CL_platform_sel != 1)
12416 {
12417 log_error ("ERROR: OpenCL platform number %d is not available", CL_platform_sel);
12418
12419 return (-1);
12420 }
12421 }
12422
12423 // zero-indexed: not starting to count at 1, as user does
12424
12425 CL_platform_sel -= 1;
12426
12427 cl_platform_id CL_platform = CL_platforms[CL_platform_sel];
12428
12429 char CL_platform_vendor[INFOSZ];
12430
12431 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12432
12433 hc_clGetPlatformInfo (CL_platform, CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12434
12435 uint vendor_id;
12436
12437 if (strcmp (CL_platform_vendor, CL_VENDOR_AMD) == 0)
12438 {
12439 vendor_id = VENDOR_ID_AMD;
12440 }
12441 else if (strcmp (CL_platform_vendor, CL_VENDOR_NV) == 0)
12442 {
12443 vendor_id = VENDOR_ID_NV;
12444
12445 // make sure that we do not directly control the fan for NVidia
12446
12447 gpu_temp_retain = 0;
12448
12449 data.gpu_temp_retain = gpu_temp_retain;
12450 }
12451 else if (strcmp (CL_platform_vendor, CL_VENDOR_POCL) == 0)
12452 {
12453 if (force == 0)
12454 {
12455 log_error ("");
12456 log_error ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12457 log_error ("You are STRONGLY encouraged not to use it");
12458 log_error ("You can use --force to override this but do not post error reports if you do so");
12459
12460 return (-1);
12461 }
12462
12463 vendor_id = VENDOR_ID_GENERIC;
12464 }
12465 else
12466 {
12467 vendor_id = VENDOR_ID_GENERIC;
12468 }
12469
12470 if (vendor_id == VENDOR_ID_GENERIC)
12471 {
12472 log_error ("Warning: unknown OpenCL vendor '%s' detected", CL_platform_vendor);
12473
12474 gpu_temp_disable = 1;
12475 }
12476
12477 data.vendor_id = vendor_id;
12478
12479 /**
12480 * cached kernel path depends on vendor_id which we don't know, so create it here
12481 */
12482
12483 int vendor_id_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 10 + 1;
12484
12485 char *vendor_id_folder = (char *) mymalloc (vendor_id_folder_size);
12486
12487 snprintf (vendor_id_folder, vendor_id_folder_size - 1, "%s/kernels", profile_dir);
12488
12489 mkdir (vendor_id_folder, 0700);
12490
12491 snprintf (vendor_id_folder, vendor_id_folder_size - 1, "%s/kernels/%d", profile_dir, vendor_id);
12492
12493 mkdir (vendor_id_folder, 0700);
12494
12495 myfree (vendor_id_folder);
12496
12497 /**
12498 * devices
12499 */
12500
12501 cl_device_id devices_all[DEVICES_MAX];
12502 cl_device_id devices[DEVICES_MAX];
12503
12504 uint devices_all_cnt = 0;
12505
12506 hc_clGetDeviceIDs (CL_platform, device_types_filter, DEVICES_MAX, devices_all, (uint *) &devices_all_cnt);
12507
12508 int hm_adapters_all = devices_all_cnt;
12509
12510 hm_attrs_t hm_adapter_all[DEVICES_MAX];
12511
12512 memset (hm_adapter_all, 0, sizeof (hm_adapter_all));
12513
12514 if (gpu_temp_disable == 0)
12515 {
12516 if (vendor_id == VENDOR_ID_NV)
12517 {
12518 #ifdef LINUX
12519 HM_LIB hm_dll = hm_init ();
12520
12521 data.hm_dll = hm_dll;
12522
12523 if (hc_NVML_nvmlInit (hm_dll) == NVML_SUCCESS)
12524 {
12525 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12526
12527 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12528
12529 int tmp_out = 0;
12530
12531 for (int i = 0; i < tmp_in; i++)
12532 {
12533 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12534 }
12535
12536 hm_adapters_all = tmp_out;
12537
12538 for (int i = 0; i < tmp_out; i++)
12539 {
12540 unsigned int speed;
12541
12542 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;
12543 }
12544 }
12545 #endif
12546
12547 #ifdef WIN
12548 if (NvAPI_Initialize () == NVAPI_OK)
12549 {
12550 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12551
12552 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12553
12554 int tmp_out = 0;
12555
12556 for (int i = 0; i < tmp_in; i++)
12557 {
12558 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12559 }
12560
12561 hm_adapters_all = tmp_out;
12562
12563 for (int i = 0; i < tmp_out; i++)
12564 {
12565 NvU32 speed;
12566
12567 if (NvAPI_GPU_GetTachReading (hm_adapter_all[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12568 }
12569 }
12570 #endif
12571 }
12572
12573 if (vendor_id == VENDOR_ID_AMD)
12574 {
12575 HM_LIB hm_dll = hm_init ();
12576
12577 data.hm_dll = hm_dll;
12578
12579 if (hc_ADL_Main_Control_Create (hm_dll, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12580 {
12581 // total number of adapters
12582
12583 int hm_adapters_num;
12584
12585 if (get_adapters_num_amd (hm_dll, &hm_adapters_num) != 0) return (-1);
12586
12587 // adapter info
12588
12589 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll, hm_adapters_num);
12590
12591 if (lpAdapterInfo == NULL) return (-1);
12592
12593 // get a list (of ids of) valid/usable adapters
12594
12595 int num_adl_adapters = 0;
12596
12597 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12598
12599 if (num_adl_adapters > 0)
12600 {
12601 hc_thread_mutex_lock (mux_adl);
12602
12603 // hm_get_opencl_busid_devid (hm_adapter_all, devices_all_cnt, devices_all);
12604
12605 hm_get_adapter_index_amd (hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12606
12607 hm_get_overdrive_version (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12608 hm_check_fanspeed_control (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12609
12610 hc_thread_mutex_unlock (mux_adl);
12611 }
12612
12613 hm_adapters_all = num_adl_adapters;
12614
12615 myfree (valid_adl_device_list);
12616 myfree (lpAdapterInfo);
12617 }
12618 }
12619 }
12620
12621 if (hm_adapters_all == 0)
12622 {
12623 gpu_temp_disable = 1;
12624 }
12625
12626 if (gpu_temp_disable == 1)
12627 {
12628 gpu_temp_abort = 0;
12629 gpu_temp_retain = 0;
12630 }
12631
12632 /**
12633 * enable custom signal handler(s)
12634 */
12635
12636 if (benchmark == 0)
12637 {
12638 hc_signal (sigHandler_default);
12639 }
12640 else
12641 {
12642 hc_signal (sigHandler_benchmark);
12643 }
12644
12645 /**
12646 * devices mask and properties
12647 */
12648
12649 uint hm_adapter_index = 0;
12650
12651 uint devices_cnt = 0;
12652
12653 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
12654 {
12655 const uint device_id = devices_cnt;
12656
12657 devices[device_id] = devices_all[device_all_id];
12658
12659 cl_device_type device_type;
12660
12661 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12662
12663 // skip the device, if the user did specify a list of GPUs to skip
12664
12665 if (opencl_devicemask)
12666 {
12667 uint device_all_id_mask = 1 << device_all_id;
12668
12669 if ((device_all_id_mask & opencl_devicemask) != device_all_id_mask)
12670 {
12671 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped by user", device_all_id_mask + 1);
12672
12673 if (device_type & CL_DEVICE_TYPE_GPU) hm_adapter_index++;
12674
12675 continue;
12676 }
12677 }
12678
12679 char device_name[INFOSZ];
12680
12681 memset (device_name, 0, sizeof (device_name));
12682
12683 cl_ulong global_mem_size;
12684 cl_ulong max_mem_alloc_size;
12685 cl_uint max_clock_frequency;
12686 cl_uint max_compute_units;
12687
12688 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
12689 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
12690 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12691 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
12692 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12693
12694 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12695 {
12696 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12697 device_all_id + 1,
12698 device_name,
12699 (unsigned int) (max_mem_alloc_size / 1024 / 1024),
12700 (unsigned int) (global_mem_size / 1024 / 1024),
12701 (unsigned int) (max_clock_frequency),
12702 (unsigned int) max_compute_units);
12703 }
12704
12705 // copy hm_adapter info to data.hm_device[]
12706
12707 uint hm_adapter_cur = hm_adapter_index;
12708
12709 if ((device_type & CL_DEVICE_TYPE_GPU) == 0)
12710 {
12711 // assign a CPU adapter (i.e. not initialized hm_adapter_all[] entry)
12712
12713 hm_adapter_cur = devices_all_cnt - 1;
12714 }
12715
12716 memcpy (&data.hm_device[device_id], &hm_adapter_all[hm_adapter_cur], sizeof (hm_attrs_t));
12717
12718 if (device_type & CL_DEVICE_TYPE_GPU)
12719 {
12720 hm_adapter_index++;
12721 }
12722
12723 devices_cnt++;
12724 }
12725
12726 if (devices_cnt == 0)
12727 {
12728 log_error ("ERROR: No devices left that matches your specification.");
12729
12730 return (-1);
12731 }
12732
12733 data.devices_cnt = devices_cnt;
12734
12735 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12736 {
12737 log_info ("");
12738 }
12739
12740 /**
12741 * inform the user
12742 */
12743
12744 // gpu temp sanity check
12745
12746 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12747 {
12748 if (gpu_temp_abort < gpu_temp_retain)
12749 {
12750 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12751
12752 return (-1);
12753 }
12754 }
12755
12756 data.gpu_temp_disable = gpu_temp_disable;
12757 data.gpu_temp_abort = gpu_temp_abort;
12758 data.gpu_temp_retain = gpu_temp_retain;
12759
12760 if (data.quiet == 0)
12761 {
12762 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12763
12764 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);
12765
12766 if (attack_mode == ATTACK_MODE_STRAIGHT)
12767 {
12768 log_info ("Rules: %u", kernel_rules_cnt);
12769 }
12770
12771 if (opti_type)
12772 {
12773 log_info ("Applicable Optimizers:");
12774
12775 for (uint i = 0; i < 32; i++)
12776 {
12777 const uint opti_bit = 1 << i;
12778
12779 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12780 }
12781 }
12782
12783 /**
12784 * Watchdog and Temperature balance
12785 */
12786
12787 if (gpu_temp_abort == 0)
12788 {
12789 log_info ("Watchdog: Temperature abort trigger disabled");
12790 }
12791 else
12792 {
12793 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12794 }
12795
12796 if (gpu_temp_retain == 0)
12797 {
12798 log_info ("Watchdog: Temperature retain trigger disabled");
12799 }
12800 else
12801 {
12802 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12803 }
12804 }
12805
12806 /**
12807 * devices init
12808 */
12809
12810 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12811
12812 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12813
12814 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12815
12816 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
12817
12818 data.devices_param = devices_param;
12819
12820 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12821 {
12822 hc_device_param_t *device_param = &data.devices_param[device_id];
12823
12824 cl_device_id device = devices[device_id];
12825
12826 device_param->device = device;
12827
12828 cl_device_type device_type = 0;
12829
12830 hc_clGetDeviceInfo (device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12831
12832 device_param->device_type = device_type;
12833
12834 cl_uint max_compute_units = 0;
12835
12836 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12837
12838 device_param->device_processors = max_compute_units;
12839
12840 cl_ulong max_mem_alloc_size = 0;
12841
12842 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12843
12844 device_param->device_maxmem_alloc = max_mem_alloc_size;
12845
12846 char tmp[INFOSZ], t1[64];
12847
12848 memset (tmp, 0, sizeof (tmp));
12849
12850 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
12851
12852 device_param->device_name = mystrdup (tmp);
12853
12854 memset (tmp, 0, sizeof (tmp));
12855
12856 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
12857
12858 memset (t1, 0, sizeof (t1));
12859
12860 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
12861
12862 device_param->device_version = mystrdup (t1);
12863
12864 memset (tmp, 0, sizeof (tmp));
12865
12866 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
12867
12868 device_param->driver_version = mystrdup (tmp);
12869
12870 // create some filename that is easier to read on cached folder
12871
12872 snprintf (tmp, sizeof (tmp) - 1, "%s-%s-%s-%d", device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12873
12874 uint device_name_digest[4];
12875
12876 device_name_digest[0] = 0;
12877 device_name_digest[1] = 0;
12878 device_name_digest[2] = 0;
12879 device_name_digest[3] = 0;
12880
12881 md5_64 ((uint *) tmp, device_name_digest);
12882
12883 sprintf (tmp, "%08x", device_name_digest[0]);
12884
12885 device_param->device_name_chksum = mystrdup (tmp);
12886
12887 if (device_type & CL_DEVICE_TYPE_CPU)
12888 {
12889 cl_uint device_processor_cores = 1;
12890
12891 device_param->device_processor_cores = device_processor_cores;
12892 }
12893
12894 if (device_type & CL_DEVICE_TYPE_GPU)
12895 {
12896 if (vendor_id == VENDOR_ID_AMD)
12897 {
12898 cl_uint device_processor_cores = 0;
12899
12900 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12901
12902 hc_clGetDeviceInfo (device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12903
12904 device_param->device_processor_cores = device_processor_cores;
12905 }
12906
12907 if (vendor_id == VENDOR_ID_NV)
12908 {
12909 cl_uint kernel_exec_timeout = 0;
12910
12911 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12912
12913 hc_clGetDeviceInfo (device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12914
12915 device_param->kernel_exec_timeout = kernel_exec_timeout;
12916
12917 cl_uint device_processor_cores = 0;
12918
12919 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12920
12921 hc_clGetDeviceInfo (device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12922
12923 device_param->device_processor_cores = device_processor_cores;
12924
12925 cl_uint sm_minor = 0;
12926 cl_uint sm_major = 0;
12927
12928 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12929 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12930
12931 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12932 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12933
12934 device_param->sm_minor = sm_minor;
12935 device_param->sm_major = sm_major;
12936 }
12937 }
12938
12939 /**
12940 * common driver check
12941 */
12942
12943 if (device_type & CL_DEVICE_TYPE_GPU)
12944 {
12945 if (vendor_id == VENDOR_ID_NV)
12946 {
12947 if (device_param->kernel_exec_timeout != 0)
12948 {
12949 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);
12950 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12951 }
12952 }
12953
12954 if (vendor_id == VENDOR_ID_AMD)
12955 {
12956 int catalyst_check = (force == 1) ? 0 : 1;
12957
12958 int catalyst_warn = 0;
12959
12960 int catalyst_broken = 0;
12961
12962 if (catalyst_check == 1)
12963 {
12964 catalyst_warn = 1;
12965
12966 // v14.9 and higher
12967 if ((atoi (device_param->device_version) >= 1573)
12968 && (atoi (device_param->driver_version) >= 1573))
12969 {
12970 catalyst_warn = 0;
12971 }
12972
12973 catalyst_check = 0;
12974 }
12975
12976 if (catalyst_broken == 1)
12977 {
12978 log_error ("");
12979 log_error ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12980 log_error ("It will pass over cracked hashes and does not report them as cracked");
12981 log_error ("You are STRONGLY encouraged not to use it");
12982 log_error ("You can use --force to override this but do not post error reports if you do so");
12983
12984 return (-1);
12985 }
12986
12987 if (catalyst_warn == 1)
12988 {
12989 log_error ("");
12990 log_error ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12991 log_error ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12992 log_error ("See oclHashcat's homepage for official supported catalyst drivers");
12993 #ifdef _WIN
12994 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12995 #endif
12996 log_error ("You can use --force to override this but do not post error reports if you do so");
12997
12998 return (-1);
12999 }
13000 }
13001 }
13002 }
13003
13004 /*
13005 * Temporary fix:
13006 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13007 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13008 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13009 * Driver / ADL bug?
13010 */
13011
13012 if (vendor_id == VENDOR_ID_AMD)
13013 {
13014 if (powertune_enable == 1)
13015 {
13016 hc_thread_mutex_lock (mux_adl);
13017
13018 for (uint i = 0; i < devices_cnt; i++)
13019 {
13020 if (data.hm_device[i].od_version == 6)
13021 {
13022 // set powertune value only
13023
13024 int powertune_supported = 0;
13025
13026 int ADL_rc = 0;
13027
13028 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
13029 {
13030 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13031
13032 return (-1);
13033 }
13034
13035 if (powertune_supported != 0)
13036 {
13037 // powertune set
13038 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13039
13040 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune)) != ADL_OK)
13041 {
13042 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13043
13044 return (-1);
13045 }
13046
13047 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13048 {
13049 log_error ("ERROR: Failed to set new ADL PowerControl values");
13050
13051 return (-1);
13052 }
13053 }
13054 }
13055 }
13056
13057 hc_thread_mutex_unlock (mux_adl);
13058 }
13059 }
13060
13061 uint kernel_blocks_all = 0;
13062
13063 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13064 {
13065 /**
13066 * host buffer
13067 */
13068
13069 hc_device_param_t *device_param = &data.devices_param[device_id];
13070
13071 /**
13072 * device properties
13073 */
13074
13075 char *device_name_chksum = device_param->device_name_chksum;
13076
13077 uint device_processors = device_param->device_processors;
13078
13079 uint device_processor_cores = device_param->device_processor_cores;
13080
13081 cl_device_type device_type = device_param->device_type;
13082
13083 /**
13084 * create context for each device
13085 */
13086
13087 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13088
13089 /**
13090 * create command-queue
13091 */
13092
13093 // not support with NV
13094 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13095
13096 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13097
13098 /**
13099 * create input buffers on device
13100 */
13101
13102 uint kernel_threads = KERNEL_THREADS;
13103
13104 // bcrypt
13105 if (hash_mode == 3200) kernel_threads = 8;
13106 if (hash_mode == 9000) kernel_threads = 8;
13107
13108 if (device_type & CL_DEVICE_TYPE_CPU)
13109 {
13110 // CPU still need lots of workitems, don't know why...
13111 // for testing phase, lets start with this
13112
13113 kernel_accel = 1;
13114 }
13115
13116 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13117 uint kernel_blocks = kernel_power;
13118
13119 device_param->kernel_threads = kernel_threads;
13120 device_param->kernel_power_user = kernel_power;
13121 device_param->kernel_blocks_user = kernel_blocks;
13122
13123 kernel_blocks_all += kernel_blocks;
13124
13125 uint size_pws = kernel_power * sizeof (pw_t);
13126
13127 uint size_tmps = 4;
13128
13129 switch (hash_mode)
13130 {
13131 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13132 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13133 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13134 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13135 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13136 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13137 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13138 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13139 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13140 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13141 case 6211:
13142 case 6212:
13143 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13144 case 6221:
13145 case 6222:
13146 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13147 case 6231:
13148 case 6232:
13149 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13150 case 6241:
13151 case 6242:
13152 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13153 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13154 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13155 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13156 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13157 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13158 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13159 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13160 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13161 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13162 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13163 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13164 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13165 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13166 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13167 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13168 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13169 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13170 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13171 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13172 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13173 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13174 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13175 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13176 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13177 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13178 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13179 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13180 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13181 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13182 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13183 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13184 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13185 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13186 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13187 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13188 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13189 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13190 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13191 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13192 };
13193
13194 uint size_hooks = 4;
13195
13196 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13197 {
13198 // insert correct hook size
13199 }
13200
13201 // we can optimize some stuff here...
13202
13203 device_param->size_pws = size_pws;
13204 device_param->size_tmps = size_tmps;
13205 device_param->size_hooks = size_hooks;
13206
13207 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13208 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13209
13210 device_param->size_root_css = size_root_css;
13211 device_param->size_markov_css = size_markov_css;
13212
13213 uint size_results = KERNEL_THREADS * sizeof (uint);
13214
13215 device_param->size_results = size_results;
13216
13217 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13218 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13219
13220 uint size_plains = digests_cnt * sizeof (plain_t);
13221 uint size_salts = salts_cnt * sizeof (salt_t);
13222 uint size_esalts = salts_cnt * esalt_size;
13223
13224 device_param->size_plains = size_plains;
13225 device_param->size_digests = size_digests;
13226 device_param->size_shown = size_shown;
13227 device_param->size_salts = size_salts;
13228
13229 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13230 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13231 uint size_tm = 32 * sizeof (bs_word_t);
13232
13233 uint64_t size_scryptV = 1;
13234
13235 if ((hash_mode == 8900) || (hash_mode == 9300))
13236 {
13237 uint tmto_start = 0;
13238 uint tmto_stop = 10;
13239
13240 if (scrypt_tmto)
13241 {
13242 tmto_start = scrypt_tmto;
13243 }
13244 else
13245 {
13246 // in case the user did not specify the tmto manually
13247 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13248 // but set the lower end only in case the user has a device with too less memory
13249
13250 if (hash_mode == 8900)
13251 {
13252 if (vendor_id == VENDOR_ID_AMD)
13253 {
13254 tmto_start = 1;
13255 }
13256 else if (vendor_id == VENDOR_ID_NV)
13257 {
13258 tmto_start = 3;
13259 }
13260 }
13261 else if (hash_mode == 9300)
13262 {
13263 if (vendor_id == VENDOR_ID_AMD)
13264 {
13265 tmto_start = 3;
13266 }
13267 else if (vendor_id == VENDOR_ID_NV)
13268 {
13269 tmto_start = 5;
13270 }
13271 }
13272 }
13273
13274 if (quiet == 0) log_info ("");
13275
13276 uint shader_per_mp = 1;
13277
13278 if (vendor_id == VENDOR_ID_AMD)
13279 {
13280 shader_per_mp = 8;
13281 }
13282
13283 if (vendor_id == VENDOR_ID_NV)
13284 {
13285 shader_per_mp = 32;
13286 }
13287
13288 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13289 {
13290 // TODO: in theory the following calculation needs to be done per salt, not global
13291 // we assume all hashes have the same scrypt settings
13292
13293 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13294
13295 size_scryptV /= 1 << tmto;
13296
13297 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13298
13299 if (size_scryptV > device_param->device_maxmem_alloc)
13300 {
13301 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13302
13303 continue;
13304 }
13305
13306 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13307 {
13308 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13309 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13310 }
13311
13312 break;
13313 }
13314
13315 if (data.salts_buf[0].scrypt_phy == 0)
13316 {
13317 log_error ("ERROR: can't allocate enough device memory");
13318
13319 return -1;
13320 }
13321
13322 if (quiet == 0) log_info ("");
13323 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13324 }
13325
13326 /**
13327 * default building options
13328 */
13329
13330 char build_opts[1024];
13331
13332 // we don't have sm_* on AMD but it doesn't matter
13333
13334 sprintf (build_opts, "-I%s/ -DVENDOR_ID=%d -DCUDA_ARCH=%d", shared_dir, vendor_id, (device_param->sm_major * 100) + device_param->sm_minor);
13335
13336 /**
13337 * a0 kernel, required for some fast hashes to make weak_hash_check work
13338 */
13339
13340 const uint add_flag = OPTS_TYPE_PT_ADD01
13341 | OPTS_TYPE_PT_ADD02
13342 | OPTS_TYPE_PT_ADD80
13343 | OPTS_TYPE_PT_ADDBITS14
13344 | OPTS_TYPE_PT_ADDBITS15
13345 | OPTS_TYPE_ST_ADD01
13346 | OPTS_TYPE_ST_ADD02
13347 | OPTS_TYPE_ST_ADD80
13348 | OPTS_TYPE_ST_ADDBITS14
13349 | OPTS_TYPE_ST_ADDBITS15;
13350
13351 if ((weak_hash_threshold) && (attack_exec == ATTACK_EXEC_INSIDE_KERNEL) && (opts_type & add_flag))
13352 {
13353 /**
13354 * kernel source filename
13355 */
13356
13357 char source_file[256];
13358
13359 memset (source_file, 0, sizeof (source_file));
13360
13361 generate_source_kernel_filename (attack_exec, ATTACK_KERN_STRAIGHT, kern_type, shared_dir, source_file);
13362
13363 struct stat sst;
13364
13365 if (stat (source_file, &sst) == -1)
13366 {
13367 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13368
13369 return -1;
13370 }
13371
13372 /**
13373 * kernel cached filename
13374 */
13375
13376 char cached_file[256];
13377
13378 memset (cached_file, 0, sizeof (cached_file));
13379
13380 generate_cached_kernel_filename (attack_exec, ATTACK_KERN_STRAIGHT, kern_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13381
13382 int cached = 1;
13383
13384 struct stat cst;
13385
13386 if (stat (cached_file, &cst) == -1)
13387 {
13388 cached = 0;
13389 }
13390
13391 /**
13392 * kernel compile or load
13393 */
13394
13395 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13396
13397 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13398
13399 if (force_jit_compilation == 0)
13400 {
13401 if (cached == 0)
13402 {
13403 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13404
13405 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13406
13407 device_param->program_weak = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13408
13409 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13410
13411 size_t binary_size;
13412
13413 clGetProgramInfo (device_param->program_weak, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13414
13415 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13416
13417 clGetProgramInfo (device_param->program_weak, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13418
13419 writeProgramBin (cached_file, binary, binary_size);
13420
13421 local_free (binary);
13422 }
13423 else
13424 {
13425 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13426
13427 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13428
13429 device_param->program_weak = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13430
13431 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13432 }
13433 }
13434 else
13435 {
13436 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13437
13438 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13439
13440 device_param->program_weak = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13441
13442 if (force_jit_compilation == 1500)
13443 {
13444 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13445 }
13446 else if (force_jit_compilation == 8900)
13447 {
13448 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);
13449 }
13450
13451 hc_clBuildProgram (device_param->program_weak, 1, &device_param->device, build_opts, NULL, NULL);
13452 }
13453
13454 local_free (kernel_lengths);
13455 local_free (kernel_sources[0]);
13456 local_free (kernel_sources);
13457
13458 // this is mostly for debug
13459
13460 size_t ret_val_size = 0;
13461
13462 clGetProgramBuildInfo (device_param->program_weak, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13463
13464 if (ret_val_size > 2)
13465 {
13466 char *build_log = (char *) mymalloc (ret_val_size + 1);
13467
13468 memset (build_log, 0, ret_val_size + 1);
13469
13470 clGetProgramBuildInfo (device_param->program_weak, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13471
13472 puts (build_log);
13473
13474 myfree (build_log);
13475 }
13476 }
13477
13478 /**
13479 * main kernel
13480 */
13481
13482 {
13483 /**
13484 * kernel source filename
13485 */
13486
13487 char source_file[256];
13488
13489 memset (source_file, 0, sizeof (source_file));
13490
13491 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13492
13493 struct stat sst;
13494
13495 if (stat (source_file, &sst) == -1)
13496 {
13497 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13498
13499 return -1;
13500 }
13501
13502 /**
13503 * kernel cached filename
13504 */
13505
13506 char cached_file[256];
13507
13508 memset (cached_file, 0, sizeof (cached_file));
13509
13510 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13511
13512 int cached = 1;
13513
13514 struct stat cst;
13515
13516 if (stat (cached_file, &cst) == -1)
13517 {
13518 cached = 0;
13519 }
13520
13521 /**
13522 * kernel compile or load
13523 */
13524
13525 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13526
13527 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13528
13529 if (force_jit_compilation == 0)
13530 {
13531 if (cached == 0)
13532 {
13533 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13534
13535 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13536
13537 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13538
13539 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13540
13541 size_t binary_size;
13542
13543 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13544
13545 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13546
13547 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13548
13549 writeProgramBin (cached_file, binary, binary_size);
13550
13551 local_free (binary);
13552 }
13553 else
13554 {
13555 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13556
13557 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13558
13559 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13560
13561 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13562 }
13563 }
13564 else
13565 {
13566 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13567
13568 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13569
13570 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13571
13572 if (force_jit_compilation == 1500)
13573 {
13574 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13575 }
13576 else if (force_jit_compilation == 8900)
13577 {
13578 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);
13579 }
13580
13581 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13582 }
13583
13584 local_free (kernel_lengths);
13585 local_free (kernel_sources[0]);
13586 local_free (kernel_sources);
13587
13588 // this is mostly for debug
13589
13590 size_t ret_val_size = 0;
13591
13592 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13593
13594 if (ret_val_size > 2)
13595 {
13596 char *build_log = (char *) mymalloc (ret_val_size + 1);
13597
13598 memset (build_log, 0, ret_val_size + 1);
13599
13600 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13601
13602 puts (build_log);
13603
13604 myfree (build_log);
13605 }
13606 }
13607
13608 /**
13609 * word generator kernel
13610 */
13611
13612 if (attack_mode != ATTACK_MODE_STRAIGHT)
13613 {
13614 /**
13615 * kernel mp source filename
13616 */
13617
13618 char source_file[256];
13619
13620 memset (source_file, 0, sizeof (source_file));
13621
13622 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13623
13624 struct stat sst;
13625
13626 if (stat (source_file, &sst) == -1)
13627 {
13628 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13629
13630 return -1;
13631 }
13632
13633 /**
13634 * kernel mp cached filename
13635 */
13636
13637 char cached_file[256];
13638
13639 memset (cached_file, 0, sizeof (cached_file));
13640
13641 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13642
13643 int cached = 1;
13644
13645 struct stat cst;
13646
13647 if (stat (cached_file, &cst) == -1)
13648 {
13649 cached = 0;
13650 }
13651
13652 /**
13653 * kernel compile or load
13654 */
13655
13656 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13657
13658 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13659
13660 if (cached == 0)
13661 {
13662 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13663
13664 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13665
13666 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13667
13668 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13669
13670 size_t binary_size;
13671
13672 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13673
13674 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13675
13676 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13677
13678 writeProgramBin (cached_file, binary, binary_size);
13679
13680 local_free (binary);
13681 }
13682 else
13683 {
13684 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13685
13686 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13687
13688 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13689
13690 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13691 }
13692
13693 local_free (kernel_lengths);
13694 local_free (kernel_sources[0]);
13695 local_free (kernel_sources);
13696
13697 // this is mostly for debug
13698
13699 size_t ret_val_size = 0;
13700
13701 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13702
13703 if (ret_val_size > 2)
13704 {
13705 char *build_log = (char *) mymalloc (ret_val_size + 1);
13706
13707 memset (build_log, 0, ret_val_size + 1);
13708
13709 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13710
13711 puts (build_log);
13712
13713 myfree (build_log);
13714 }
13715 }
13716
13717 /**
13718 * amplifier kernel
13719 */
13720
13721 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13722 {
13723
13724 }
13725 else
13726 {
13727 /**
13728 * kernel amp source filename
13729 */
13730
13731 char source_file[256];
13732
13733 memset (source_file, 0, sizeof (source_file));
13734
13735 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13736
13737 struct stat sst;
13738
13739 if (stat (source_file, &sst) == -1)
13740 {
13741 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13742
13743 return -1;
13744 }
13745
13746 /**
13747 * kernel amp cached filename
13748 */
13749
13750 char cached_file[256];
13751
13752 memset (cached_file, 0, sizeof (cached_file));
13753
13754 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, vendor_id, cached_file);
13755
13756 int cached = 1;
13757
13758 struct stat cst;
13759
13760 if (stat (cached_file, &cst) == -1)
13761 {
13762 cached = 0;
13763 }
13764
13765 /**
13766 * kernel compile or load
13767 */
13768
13769 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13770
13771 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13772
13773 if (cached == 0)
13774 {
13775 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13776
13777 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13778
13779 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13780
13781 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13782
13783 size_t binary_size;
13784
13785 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13786
13787 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13788
13789 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13790
13791 writeProgramBin (cached_file, binary, binary_size);
13792
13793 local_free (binary);
13794 }
13795 else
13796 {
13797 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13798
13799 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13800
13801 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13802
13803 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13804 }
13805
13806 local_free (kernel_lengths);
13807 local_free (kernel_sources[0]);
13808 local_free (kernel_sources);
13809
13810 // this is mostly for debug
13811
13812 size_t ret_val_size = 0;
13813
13814 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13815
13816 if (ret_val_size > 2)
13817 {
13818 char *build_log = (char *) mymalloc (ret_val_size + 1);
13819
13820 memset (build_log, 0, ret_val_size + 1);
13821
13822 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13823
13824 puts (build_log);
13825
13826 myfree (build_log);
13827 }
13828 }
13829
13830 /**
13831 * global buffers
13832 */
13833
13834 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13835 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13836 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13837 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13838 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13839 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13840 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13841 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13842 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13843 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13844 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13845 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13846 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13847 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13848 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13849 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13850 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13851 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13852
13853 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13854 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13855 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13856 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13857 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13858 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13859 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13860 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13861 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13862 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13863 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13864
13865 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13866 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13867 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13868 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13869 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13870 run_kernel_bzero (device_param, device_param->d_result, size_results);
13871
13872 /**
13873 * special buffers
13874 */
13875
13876 if (attack_kern == ATTACK_KERN_STRAIGHT)
13877 {
13878 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13879 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13880
13881 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13882
13883 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13884 }
13885 else if (attack_kern == ATTACK_KERN_COMBI)
13886 {
13887 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13888 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13889 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13890 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13891
13892 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13893 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13894 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13895 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13896 }
13897 else if (attack_kern == ATTACK_KERN_BF)
13898 {
13899 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13900 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13901 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13902 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13903 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13904
13905 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13906 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13907 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13908 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13909 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13910 }
13911
13912 if (size_esalts)
13913 {
13914 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13915
13916 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13917 }
13918
13919 /**
13920 * main host data
13921 */
13922
13923 uint *result = (uint *) mymalloc (size_results);
13924
13925 memset (result, 0, size_results);
13926
13927 device_param->result = result;
13928
13929 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13930
13931 memset (pws_buf, 0, size_pws);
13932
13933 device_param->pws_buf = pws_buf;
13934
13935 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13936
13937 for (int i = 0; i < 64; i++)
13938 {
13939 pw_caches[i].pw_buf.pw_len = i;
13940 pw_caches[i].cnt = 0;
13941 }
13942
13943 device_param->pw_caches = pw_caches;
13944
13945 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13946
13947 device_param->combs_buf = combs_buf;
13948
13949 void *hooks_buf = mymalloc (size_hooks);
13950
13951 device_param->hooks_buf = hooks_buf;
13952
13953 device_param->pw_transpose = pw_transpose_to_hi1;
13954 device_param->pw_add = pw_add_to_hc1;
13955
13956 /**
13957 * kernel args
13958 */
13959
13960 device_param->kernel_params_buf32[21] = bitmap_mask;
13961 device_param->kernel_params_buf32[22] = bitmap_shift1;
13962 device_param->kernel_params_buf32[23] = bitmap_shift2;
13963 device_param->kernel_params_buf32[24] = 0; // salt_pos
13964 device_param->kernel_params_buf32[25] = 0; // loop_pos
13965 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13966 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13967 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13968 device_param->kernel_params_buf32[29] = 0; // digests_offset
13969 device_param->kernel_params_buf32[30] = 0; // combs_mode
13970 device_param->kernel_params_buf32[31] = 0; // gid_max
13971
13972 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13973 ? &device_param->d_pws_buf
13974 : &device_param->d_pws_amp_buf;
13975 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13976 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13977 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13978 device_param->kernel_params[ 4] = &device_param->d_tmps;
13979 device_param->kernel_params[ 5] = &device_param->d_hooks;
13980 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13981 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13982 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13983 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13984 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13985 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13986 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13987 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13988 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13989 device_param->kernel_params[15] = &device_param->d_digests_buf;
13990 device_param->kernel_params[16] = &device_param->d_digests_shown;
13991 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13992 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13993 device_param->kernel_params[19] = &device_param->d_result;
13994 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13995 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13996 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13997 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13998 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13999 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14000 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14001 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14002 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14003 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14004 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14005 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14006
14007 device_param->kernel_params_mp_buf64[3] = 0;
14008 device_param->kernel_params_mp_buf32[4] = 0;
14009 device_param->kernel_params_mp_buf32[5] = 0;
14010 device_param->kernel_params_mp_buf32[6] = 0;
14011 device_param->kernel_params_mp_buf32[7] = 0;
14012 device_param->kernel_params_mp_buf32[8] = 0;
14013
14014 device_param->kernel_params_mp[0] = NULL;
14015 device_param->kernel_params_mp[1] = NULL;
14016 device_param->kernel_params_mp[2] = NULL;
14017 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14018 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14019 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14020 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14021 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14022 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14023
14024 device_param->kernel_params_mp_l_buf64[3] = 0;
14025 device_param->kernel_params_mp_l_buf32[4] = 0;
14026 device_param->kernel_params_mp_l_buf32[5] = 0;
14027 device_param->kernel_params_mp_l_buf32[6] = 0;
14028 device_param->kernel_params_mp_l_buf32[7] = 0;
14029 device_param->kernel_params_mp_l_buf32[8] = 0;
14030 device_param->kernel_params_mp_l_buf32[9] = 0;
14031
14032 device_param->kernel_params_mp_l[0] = NULL;
14033 device_param->kernel_params_mp_l[1] = NULL;
14034 device_param->kernel_params_mp_l[2] = NULL;
14035 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14036 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14037 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14038 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14039 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14040 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14041 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14042
14043 device_param->kernel_params_mp_r_buf64[3] = 0;
14044 device_param->kernel_params_mp_r_buf32[4] = 0;
14045 device_param->kernel_params_mp_r_buf32[5] = 0;
14046 device_param->kernel_params_mp_r_buf32[6] = 0;
14047 device_param->kernel_params_mp_r_buf32[7] = 0;
14048 device_param->kernel_params_mp_r_buf32[8] = 0;
14049
14050 device_param->kernel_params_mp_r[0] = NULL;
14051 device_param->kernel_params_mp_r[1] = NULL;
14052 device_param->kernel_params_mp_r[2] = NULL;
14053 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14054 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14055 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14056 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14057 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14058 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14059
14060 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14061 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14062
14063 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14064 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14065 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14066 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14067 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14068 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14069 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14070
14071 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14072
14073 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14074 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14075
14076 /**
14077 * kernel name
14078 */
14079
14080 char kernel_name[64];
14081
14082 memset (kernel_name, 0, sizeof (kernel_name));
14083
14084 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14085 {
14086 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14087 {
14088 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14089
14090 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14091
14092 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14093
14094 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14095
14096 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14097
14098 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14099 }
14100 else
14101 {
14102 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14103
14104 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14105
14106 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14107
14108 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14109
14110 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14111
14112 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14113 }
14114
14115 if (weak_hash_threshold)
14116 {
14117 if (opts_type & add_flag)
14118 {
14119 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14120 {
14121 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14122
14123 device_param->kernel_weak = hc_clCreateKernel (device_param->program_weak, kernel_name);
14124 }
14125 else
14126 {
14127 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14128
14129 device_param->kernel_weak = hc_clCreateKernel (device_param->program_weak, kernel_name);
14130 }
14131 }
14132 else
14133 {
14134 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14135 {
14136 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14137
14138 device_param->kernel_weak = hc_clCreateKernel (device_param->program, kernel_name);
14139 }
14140 else
14141 {
14142 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14143
14144 device_param->kernel_weak = hc_clCreateKernel (device_param->program, kernel_name);
14145 }
14146 }
14147 }
14148
14149 if (data.attack_mode == ATTACK_MODE_BF)
14150 {
14151 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14152 {
14153 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14154
14155 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
14156
14157 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14158
14159 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
14160 }
14161 }
14162 }
14163 else
14164 {
14165 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14166
14167 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14168
14169 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14170
14171 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14172
14173 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14174
14175 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14176
14177 if (opts_type & OPTS_TYPE_HOOK12)
14178 {
14179 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14180
14181 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
14182 }
14183
14184 if (opts_type & OPTS_TYPE_HOOK23)
14185 {
14186 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14187
14188 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
14189 }
14190 }
14191
14192 for (uint i = 0; i <= 20; i++)
14193 {
14194 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14195 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14196 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14197
14198 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14199 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14200
14201 if (weak_hash_threshold)
14202 {
14203 hc_clSetKernelArg (device_param->kernel_weak, i, sizeof (cl_mem), device_param->kernel_params[i]);
14204 }
14205 }
14206
14207 for (uint i = 21; i <= 31; i++)
14208 {
14209 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14210 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14211 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14212
14213 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14214 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14215
14216 if (weak_hash_threshold)
14217 {
14218 hc_clSetKernelArg (device_param->kernel_weak, i, sizeof (cl_uint), device_param->kernel_params[i]);
14219 }
14220 }
14221
14222 if (attack_mode == ATTACK_MODE_BF)
14223 {
14224 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
14225 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
14226
14227 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14228 {
14229 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14230
14231 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14232 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14233 }
14234 }
14235 else if (attack_mode == ATTACK_MODE_HYBRID1)
14236 {
14237 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14238 }
14239 else if (attack_mode == ATTACK_MODE_HYBRID2)
14240 {
14241 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14242 }
14243
14244 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14245 {
14246 // nothing to do
14247 }
14248 else
14249 {
14250 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14251 }
14252
14253 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14254 {
14255 // nothing to do
14256 }
14257 else
14258 {
14259 for (uint i = 0; i < 5; i++)
14260 {
14261 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14262 }
14263
14264 for (uint i = 5; i < 7; i++)
14265 {
14266 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14267 }
14268 }
14269
14270 /**
14271 * Store initial fanspeed if gpu_temp_retain is enabled
14272 */
14273
14274 int gpu_temp_retain_set = 0;
14275
14276 if (gpu_temp_disable == 0)
14277 {
14278 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14279 {
14280 hc_thread_mutex_lock (mux_adl);
14281
14282 if (data.hm_device[device_id].fan_supported == 1)
14283 {
14284 if (gpu_temp_retain_chgd == 0)
14285 {
14286 uint cur_temp = 0;
14287 uint default_temp = 0;
14288
14289 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);
14290
14291 if (ADL_rc == ADL_OK)
14292 {
14293 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14294
14295 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14296
14297 // special case with multi gpu setups: always use minimum retain
14298
14299 if (gpu_temp_retain_set == 0)
14300 {
14301 gpu_temp_retain = gpu_temp_retain_target;
14302 gpu_temp_retain_set = 1;
14303 }
14304 else
14305 {
14306 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14307 }
14308
14309 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14310 }
14311 }
14312
14313 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14314
14315 temp_retain_fanspeed_value[device_id] = fan_speed;
14316
14317 if (fan_speed == -1)
14318 {
14319 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14320
14321 temp_retain_fanspeed_value[device_id] = 0;
14322 }
14323 }
14324
14325 hc_thread_mutex_unlock (mux_adl);
14326 }
14327 }
14328
14329 /**
14330 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14331 */
14332
14333 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14334 {
14335 hc_thread_mutex_lock (mux_adl);
14336
14337 if (data.hm_device[device_id].od_version == 6)
14338 {
14339 int ADL_rc;
14340
14341 // check powertune capabilities first, if not available then skip device
14342
14343 int powertune_supported = 0;
14344
14345 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14346 {
14347 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14348
14349 return (-1);
14350 }
14351
14352 if (powertune_supported != 0)
14353 {
14354 // powercontrol settings
14355
14356 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14357
14358 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14359 {
14360 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14361 }
14362
14363 if (ADL_rc != ADL_OK)
14364 {
14365 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14366
14367 return (-1);
14368 }
14369
14370 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14371 {
14372 log_error ("ERROR: Failed to set new ADL PowerControl values");
14373
14374 return (-1);
14375 }
14376
14377 // clocks
14378
14379 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14380
14381 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14382
14383 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)
14384 {
14385 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14386
14387 return (-1);
14388 }
14389
14390 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14391
14392 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14393
14394 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14395 {
14396 log_error ("ERROR: Failed to get ADL device capabilities");
14397
14398 return (-1);
14399 }
14400
14401 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14402 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14403
14404 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14405 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14406
14407 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14408 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14409
14410 // warning if profile has to low max values
14411
14412 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14413 {
14414 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14415 }
14416
14417 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14418 {
14419 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14420 }
14421
14422 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14423
14424 performance_state->iNumberOfPerformanceLevels = 2;
14425
14426 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14427 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14428 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14429 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14430
14431 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)
14432 {
14433 log_info ("ERROR: Failed to set ADL performance state");
14434
14435 return (-1);
14436 }
14437
14438 local_free (performance_state);
14439 }
14440 }
14441
14442 hc_thread_mutex_unlock (mux_adl);
14443 }
14444 }
14445
14446 data.kernel_blocks_all = kernel_blocks_all;
14447
14448 if (data.quiet == 0) log_info ("");
14449
14450 /**
14451 * Inform user which algorithm is checked and at which workload setting
14452 */
14453
14454 if (benchmark == 1)
14455 {
14456 quiet = 0;
14457
14458 data.quiet = quiet;
14459
14460 char *hash_type = strhashtype (data.hash_mode); // not a bug
14461
14462 log_info ("Hashtype: %s", hash_type);
14463 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14464 log_info ("");
14465 }
14466
14467 /**
14468 * keep track of the progress
14469 */
14470
14471 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14472 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14473 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14474
14475 /**
14476 * open filehandles
14477 */
14478
14479 #if _WIN
14480 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14481 {
14482 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14483
14484 return (-1);
14485 }
14486
14487 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14488 {
14489 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14490
14491 return (-1);
14492 }
14493
14494 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14495 {
14496 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14497
14498 return (-1);
14499 }
14500 #endif
14501
14502 /**
14503 * dictionary pad
14504 */
14505
14506 segment_size *= (1024 * 1024);
14507
14508 data.segment_size = segment_size;
14509
14510 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14511
14512 wl_data->buf = (char *) mymalloc (segment_size);
14513 wl_data->avail = segment_size;
14514 wl_data->incr = segment_size;
14515 wl_data->cnt = 0;
14516 wl_data->pos = 0;
14517
14518 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14519
14520 data.wordlist_mode = wordlist_mode;
14521
14522 cs_t *css_buf = NULL;
14523 uint css_cnt = 0;
14524 uint dictcnt = 0;
14525 uint maskcnt = 1;
14526 char **masks = NULL;
14527 char **dictfiles = NULL;
14528
14529 uint mask_from_file = 0;
14530
14531 if (attack_mode == ATTACK_MODE_STRAIGHT)
14532 {
14533 if (wordlist_mode == WL_MODE_FILE)
14534 {
14535 int wls_left = myargc - (optind + 1);
14536
14537 for (int i = 0; i < wls_left; i++)
14538 {
14539 char *l0_filename = myargv[optind + 1 + i];
14540
14541 struct stat l0_stat;
14542
14543 if (stat (l0_filename, &l0_stat) == -1)
14544 {
14545 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14546
14547 return (-1);
14548 }
14549
14550 uint is_dir = S_ISDIR (l0_stat.st_mode);
14551
14552 if (is_dir == 0)
14553 {
14554 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14555
14556 dictcnt++;
14557
14558 dictfiles[dictcnt - 1] = l0_filename;
14559 }
14560 else
14561 {
14562 // do not allow --keyspace w/ a directory
14563
14564 if (keyspace == 1)
14565 {
14566 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14567
14568 return (-1);
14569 }
14570
14571 char **dictionary_files = NULL;
14572
14573 dictionary_files = scan_directory (l0_filename);
14574
14575 if (dictionary_files != NULL)
14576 {
14577 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14578
14579 for (int d = 0; dictionary_files[d] != NULL; d++)
14580 {
14581 char *l1_filename = dictionary_files[d];
14582
14583 struct stat l1_stat;
14584
14585 if (stat (l1_filename, &l1_stat) == -1)
14586 {
14587 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14588
14589 return (-1);
14590 }
14591
14592 if (S_ISREG (l1_stat.st_mode))
14593 {
14594 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14595
14596 dictcnt++;
14597
14598 dictfiles[dictcnt - 1] = strdup (l1_filename);
14599 }
14600 }
14601 }
14602
14603 local_free (dictionary_files);
14604 }
14605 }
14606
14607 if (dictcnt < 1)
14608 {
14609 log_error ("ERROR: No usable dictionary file found.");
14610
14611 return (-1);
14612 }
14613 }
14614 else if (wordlist_mode == WL_MODE_STDIN)
14615 {
14616 dictcnt = 1;
14617 }
14618 }
14619 else if (attack_mode == ATTACK_MODE_COMBI)
14620 {
14621 // display
14622
14623 char *dictfile1 = myargv[optind + 1 + 0];
14624 char *dictfile2 = myargv[optind + 1 + 1];
14625
14626 // find the bigger dictionary and use as base
14627
14628 FILE *fp1;
14629 FILE *fp2;
14630
14631 struct stat tmp_stat;
14632
14633 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14634 {
14635 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14636
14637 return (-1);
14638 }
14639
14640 if (stat (dictfile1, &tmp_stat) == -1)
14641 {
14642 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14643
14644 fclose (fp1);
14645
14646 return (-1);
14647 }
14648
14649 if (S_ISDIR (tmp_stat.st_mode))
14650 {
14651 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14652
14653 fclose (fp1);
14654
14655 return (-1);
14656 }
14657
14658 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14659 {
14660 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14661
14662 fclose (fp1);
14663
14664 return (-1);
14665 }
14666
14667 if (stat (dictfile2, &tmp_stat) == -1)
14668 {
14669 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14670
14671 fclose (fp1);
14672 fclose (fp2);
14673
14674 return (-1);
14675 }
14676
14677 if (S_ISDIR (tmp_stat.st_mode))
14678 {
14679 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14680
14681 fclose (fp1);
14682 fclose (fp2);
14683
14684 return (-1);
14685 }
14686
14687 data.combs_cnt = 1;
14688
14689 data.quiet = 1;
14690
14691 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14692
14693 data.quiet = quiet;
14694
14695 if (words1_cnt == 0)
14696 {
14697 log_error ("ERROR: %s: empty file", dictfile1);
14698
14699 fclose (fp1);
14700 fclose (fp2);
14701
14702 return (-1);
14703 }
14704
14705 data.combs_cnt = 1;
14706
14707 data.quiet = 1;
14708
14709 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14710
14711 data.quiet = quiet;
14712
14713 if (words2_cnt == 0)
14714 {
14715 log_error ("ERROR: %s: empty file", dictfile2);
14716
14717 fclose (fp1);
14718 fclose (fp2);
14719
14720 return (-1);
14721 }
14722
14723 fclose (fp1);
14724 fclose (fp2);
14725
14726 data.dictfile = dictfile1;
14727 data.dictfile2 = dictfile2;
14728
14729 if (words1_cnt >= words2_cnt)
14730 {
14731 data.combs_cnt = words2_cnt;
14732 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14733
14734 dictfiles = &data.dictfile;
14735
14736 dictcnt = 1;
14737 }
14738 else
14739 {
14740 data.combs_cnt = words1_cnt;
14741 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14742
14743 dictfiles = &data.dictfile2;
14744
14745 dictcnt = 1;
14746
14747 // we also have to switch wordlist related rules!
14748
14749 char *tmpc = data.rule_buf_l;
14750
14751 data.rule_buf_l = data.rule_buf_r;
14752 data.rule_buf_r = tmpc;
14753
14754 int tmpi = data.rule_len_l;
14755
14756 data.rule_len_l = data.rule_len_r;
14757 data.rule_len_r = tmpi;
14758 }
14759 }
14760 else if (attack_mode == ATTACK_MODE_BF)
14761 {
14762 char *mask = NULL;
14763
14764 maskcnt = 0;
14765
14766 if (benchmark == 0)
14767 {
14768 mask = myargv[optind + 1];
14769
14770 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14771
14772 if ((optind + 2) <= myargc)
14773 {
14774 struct stat file_stat;
14775
14776 if (stat (mask, &file_stat) == -1)
14777 {
14778 maskcnt = 1;
14779
14780 masks[maskcnt - 1] = mystrdup (mask);
14781 }
14782 else
14783 {
14784 int wls_left = myargc - (optind + 1);
14785
14786 uint masks_avail = INCR_MASKS;
14787
14788 for (int i = 0; i < wls_left; i++)
14789 {
14790 if (i != 0)
14791 {
14792 mask = myargv[optind + 1 + i];
14793
14794 if (stat (mask, &file_stat) == -1)
14795 {
14796 log_error ("ERROR: %s: %s", mask, strerror (errno));
14797
14798 return (-1);
14799 }
14800 }
14801
14802 uint is_file = S_ISREG (file_stat.st_mode);
14803
14804 if (is_file == 1)
14805 {
14806 FILE *mask_fp;
14807
14808 if ((mask_fp = fopen (mask, "r")) == NULL)
14809 {
14810 log_error ("ERROR: %s: %s", mask, strerror (errno));
14811
14812 return (-1);
14813 }
14814
14815 char line_buf[BUFSIZ];
14816
14817 while (!feof (mask_fp))
14818 {
14819 memset (line_buf, 0, BUFSIZ);
14820
14821 int line_len = fgetl (mask_fp, line_buf);
14822
14823 if (line_len == 0) continue;
14824
14825 if (line_buf[0] == '#') continue;
14826
14827 if (masks_avail == maskcnt)
14828 {
14829 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14830
14831 masks_avail += INCR_MASKS;
14832 }
14833
14834 masks[maskcnt] = mystrdup (line_buf);
14835
14836 maskcnt++;
14837 }
14838
14839 fclose (mask_fp);
14840 }
14841 else
14842 {
14843 log_error ("ERROR: %s: unsupported file-type", mask);
14844
14845 return (-1);
14846 }
14847 }
14848
14849 mask_from_file = 1;
14850 }
14851 }
14852 else
14853 {
14854 custom_charset_1 = (char *) "?l?d?u";
14855 custom_charset_2 = (char *) "?l?d";
14856 custom_charset_3 = (char *) "?l?d*!$@_";
14857
14858 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14859 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14860 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14861
14862 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14863
14864 wordlist_mode = WL_MODE_MASK;
14865
14866 data.wordlist_mode = wordlist_mode;
14867
14868 increment = 1;
14869
14870 maskcnt = 1;
14871 }
14872 }
14873 else
14874 {
14875 /**
14876 * generate full masks and charsets
14877 */
14878
14879 masks = (char **) mymalloc (sizeof (char *));
14880
14881 switch (hash_mode)
14882 {
14883 case 1731: pw_min = 5;
14884 pw_max = 5;
14885 mask = mystrdup ("?b?b?b?b?b");
14886 break;
14887 case 12500: pw_min = 5;
14888 pw_max = 5;
14889 mask = mystrdup ("?b?b?b?b?b");
14890 break;
14891 default: pw_min = 7;
14892 pw_max = 7;
14893 mask = mystrdup ("?b?b?b?b?b?b?b");
14894 break;
14895 }
14896
14897 maskcnt = 1;
14898
14899 masks[maskcnt - 1] = mystrdup (mask);
14900
14901 wordlist_mode = WL_MODE_MASK;
14902
14903 data.wordlist_mode = wordlist_mode;
14904
14905 increment = 1;
14906 }
14907
14908 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14909
14910 if (increment)
14911 {
14912 if (increment_min > pw_min) pw_min = increment_min;
14913
14914 if (increment_max < pw_max) pw_max = increment_max;
14915 }
14916 }
14917 else if (attack_mode == ATTACK_MODE_HYBRID1)
14918 {
14919 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14920
14921 // display
14922
14923 char *mask = myargv[myargc - 1];
14924
14925 maskcnt = 0;
14926
14927 masks = (char **) mymalloc (1 * sizeof (char *));
14928
14929 // mod
14930
14931 struct stat file_stat;
14932
14933 if (stat (mask, &file_stat) == -1)
14934 {
14935 maskcnt = 1;
14936
14937 masks[maskcnt - 1] = mystrdup (mask);
14938 }
14939 else
14940 {
14941 uint is_file = S_ISREG (file_stat.st_mode);
14942
14943 if (is_file == 1)
14944 {
14945 FILE *mask_fp;
14946
14947 if ((mask_fp = fopen (mask, "r")) == NULL)
14948 {
14949 log_error ("ERROR: %s: %s", mask, strerror (errno));
14950
14951 return (-1);
14952 }
14953
14954 char line_buf[BUFSIZ];
14955
14956 uint masks_avail = 1;
14957
14958 while (!feof (mask_fp))
14959 {
14960 memset (line_buf, 0, BUFSIZ);
14961
14962 int line_len = fgetl (mask_fp, line_buf);
14963
14964 if (line_len == 0) continue;
14965
14966 if (line_buf[0] == '#') continue;
14967
14968 if (masks_avail == maskcnt)
14969 {
14970 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14971
14972 masks_avail += INCR_MASKS;
14973 }
14974
14975 masks[maskcnt] = mystrdup (line_buf);
14976
14977 maskcnt++;
14978 }
14979
14980 fclose (mask_fp);
14981
14982 mask_from_file = 1;
14983 }
14984 else
14985 {
14986 maskcnt = 1;
14987
14988 masks[maskcnt - 1] = mystrdup (mask);
14989 }
14990 }
14991
14992 // base
14993
14994 int wls_left = myargc - (optind + 2);
14995
14996 for (int i = 0; i < wls_left; i++)
14997 {
14998 char *filename = myargv[optind + 1 + i];
14999
15000 struct stat file_stat;
15001
15002 if (stat (filename, &file_stat) == -1)
15003 {
15004 log_error ("ERROR: %s: %s", filename, strerror (errno));
15005
15006 return (-1);
15007 }
15008
15009 uint is_dir = S_ISDIR (file_stat.st_mode);
15010
15011 if (is_dir == 0)
15012 {
15013 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15014
15015 dictcnt++;
15016
15017 dictfiles[dictcnt - 1] = filename;
15018 }
15019 else
15020 {
15021 // do not allow --keyspace w/ a directory
15022
15023 if (keyspace == 1)
15024 {
15025 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15026
15027 return (-1);
15028 }
15029
15030 char **dictionary_files = NULL;
15031
15032 dictionary_files = scan_directory (filename);
15033
15034 if (dictionary_files != NULL)
15035 {
15036 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15037
15038 for (int d = 0; dictionary_files[d] != NULL; d++)
15039 {
15040 char *l1_filename = dictionary_files[d];
15041
15042 struct stat l1_stat;
15043
15044 if (stat (l1_filename, &l1_stat) == -1)
15045 {
15046 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15047
15048 return (-1);
15049 }
15050
15051 if (S_ISREG (l1_stat.st_mode))
15052 {
15053 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15054
15055 dictcnt++;
15056
15057 dictfiles[dictcnt - 1] = strdup (l1_filename);
15058 }
15059 }
15060 }
15061
15062 local_free (dictionary_files);
15063 }
15064 }
15065
15066 if (dictcnt < 1)
15067 {
15068 log_error ("ERROR: No usable dictionary file found.");
15069
15070 return (-1);
15071 }
15072
15073 if (increment)
15074 {
15075 maskcnt = 0;
15076
15077 uint mask_min = increment_min; // we can't reject smaller masks here
15078 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15079
15080 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15081 {
15082 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15083
15084 if (cur_mask == NULL) break;
15085
15086 masks[maskcnt] = cur_mask;
15087
15088 maskcnt++;
15089
15090 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15091 }
15092 }
15093 }
15094 else if (attack_mode == ATTACK_MODE_HYBRID2)
15095 {
15096 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15097
15098 // display
15099
15100 char *mask = myargv[optind + 1 + 0];
15101
15102 maskcnt = 0;
15103
15104 masks = (char **) mymalloc (1 * sizeof (char *));
15105
15106 // mod
15107
15108 struct stat file_stat;
15109
15110 if (stat (mask, &file_stat) == -1)
15111 {
15112 maskcnt = 1;
15113
15114 masks[maskcnt - 1] = mystrdup (mask);
15115 }
15116 else
15117 {
15118 uint is_file = S_ISREG (file_stat.st_mode);
15119
15120 if (is_file == 1)
15121 {
15122 FILE *mask_fp;
15123
15124 if ((mask_fp = fopen (mask, "r")) == NULL)
15125 {
15126 log_error ("ERROR: %s: %s", mask, strerror (errno));
15127
15128 return (-1);
15129 }
15130
15131 char line_buf[BUFSIZ];
15132
15133 uint masks_avail = 1;
15134
15135 while (!feof (mask_fp))
15136 {
15137 memset (line_buf, 0, BUFSIZ);
15138
15139 int line_len = fgetl (mask_fp, line_buf);
15140
15141 if (line_len == 0) continue;
15142
15143 if (line_buf[0] == '#') continue;
15144
15145 if (masks_avail == maskcnt)
15146 {
15147 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15148
15149 masks_avail += INCR_MASKS;
15150 }
15151
15152 masks[maskcnt] = mystrdup (line_buf);
15153
15154 maskcnt++;
15155 }
15156
15157 fclose (mask_fp);
15158
15159 mask_from_file = 1;
15160 }
15161 else
15162 {
15163 maskcnt = 1;
15164
15165 masks[maskcnt - 1] = mystrdup (mask);
15166 }
15167 }
15168
15169 // base
15170
15171 int wls_left = myargc - (optind + 2);
15172
15173 for (int i = 0; i < wls_left; i++)
15174 {
15175 char *filename = myargv[optind + 2 + i];
15176
15177 struct stat file_stat;
15178
15179 if (stat (filename, &file_stat) == -1)
15180 {
15181 log_error ("ERROR: %s: %s", filename, strerror (errno));
15182
15183 return (-1);
15184 }
15185
15186 uint is_dir = S_ISDIR (file_stat.st_mode);
15187
15188 if (is_dir == 0)
15189 {
15190 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15191
15192 dictcnt++;
15193
15194 dictfiles[dictcnt - 1] = filename;
15195 }
15196 else
15197 {
15198 // do not allow --keyspace w/ a directory
15199
15200 if (keyspace == 1)
15201 {
15202 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15203
15204 return (-1);
15205 }
15206
15207 char **dictionary_files = NULL;
15208
15209 dictionary_files = scan_directory (filename);
15210
15211 if (dictionary_files != NULL)
15212 {
15213 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15214
15215 for (int d = 0; dictionary_files[d] != NULL; d++)
15216 {
15217 char *l1_filename = dictionary_files[d];
15218
15219 struct stat l1_stat;
15220
15221 if (stat (l1_filename, &l1_stat) == -1)
15222 {
15223 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15224
15225 return (-1);
15226 }
15227
15228 if (S_ISREG (l1_stat.st_mode))
15229 {
15230 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15231
15232 dictcnt++;
15233
15234 dictfiles[dictcnt - 1] = strdup (l1_filename);
15235 }
15236 }
15237 }
15238
15239 local_free (dictionary_files);
15240 }
15241 }
15242
15243 if (dictcnt < 1)
15244 {
15245 log_error ("ERROR: No usable dictionary file found.");
15246
15247 return (-1);
15248 }
15249
15250 if (increment)
15251 {
15252 maskcnt = 0;
15253
15254 uint mask_min = increment_min; // we can't reject smaller masks here
15255 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15256
15257 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15258 {
15259 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15260
15261 if (cur_mask == NULL) break;
15262
15263 masks[maskcnt] = cur_mask;
15264
15265 maskcnt++;
15266
15267 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15268 }
15269 }
15270 }
15271
15272 data.pw_min = pw_min;
15273 data.pw_max = pw_max;
15274
15275 /**
15276 * weak hash check
15277 */
15278
15279 if (weak_hash_threshold >= salts_cnt)
15280 {
15281 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15282
15283 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15284 {
15285 weak_hash_check (&data.devices_param[0], salt_pos, kernel_loops);
15286 }
15287 }
15288
15289 // Display hack, guarantee that there is at least one \r before real start
15290
15291 if (data.quiet == 0) log_info_nn ("");
15292
15293 /**
15294 * status and monitor threads
15295 */
15296
15297 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15298
15299 hc_thread_t i_thread = 0;
15300
15301 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15302 {
15303 hc_thread_create (i_thread, thread_keypress, &benchmark);
15304 }
15305
15306 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15307
15308 uint ni_threads_cnt = 0;
15309
15310 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15311
15312 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15313
15314 ni_threads_cnt++;
15315
15316 /**
15317 * Outfile remove
15318 */
15319
15320 if (keyspace == 0)
15321 {
15322 if (outfile_check_timer != 0)
15323 {
15324 if (data.outfile_check_directory != NULL)
15325 {
15326 if ((hash_mode != 5200) &&
15327 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15328 (hash_mode != 9000))
15329 {
15330 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15331
15332 ni_threads_cnt++;
15333 }
15334 else
15335 {
15336 outfile_check_timer = 0;
15337 }
15338 }
15339 else
15340 {
15341 outfile_check_timer = 0;
15342 }
15343 }
15344 }
15345
15346 /**
15347 * Inform the user if we got some hashes remove because of the pot file remove feature
15348 */
15349
15350 if (data.quiet == 0)
15351 {
15352 if (potfile_remove_cracks > 0)
15353 {
15354 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15355 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15356 }
15357 }
15358
15359 data.outfile_check_timer = outfile_check_timer;
15360
15361 /**
15362 * main loop
15363 */
15364
15365 char **induction_dictionaries = NULL;
15366
15367 int induction_dictionaries_cnt = 0;
15368
15369 hcstat_table_t *root_table_buf = NULL;
15370 hcstat_table_t *markov_table_buf = NULL;
15371
15372 uint initial_restore_done = 0;
15373
15374 data.maskcnt = maskcnt;
15375
15376 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15377 {
15378 if (data.devices_status == STATUS_CRACKED) break;
15379
15380 data.devices_status = STATUS_INIT;
15381
15382 if (maskpos > rd->maskpos)
15383 {
15384 rd->dictpos = 0;
15385 }
15386
15387 rd->maskpos = maskpos;
15388 data.maskpos = maskpos;
15389
15390 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15391 {
15392 char *mask = masks[maskpos];
15393
15394 if (mask_from_file == 1)
15395 {
15396 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15397
15398 char *str_ptr;
15399 uint str_pos;
15400
15401 uint mask_offset = 0;
15402
15403 uint separator_cnt;
15404
15405 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15406 {
15407 str_ptr = strstr (mask + mask_offset, ",");
15408
15409 if (str_ptr == NULL) break;
15410
15411 str_pos = str_ptr - mask;
15412
15413 // escaped separator, i.e. "\,"
15414
15415 if (str_pos > 0)
15416 {
15417 if (mask[str_pos - 1] == '\\')
15418 {
15419 separator_cnt --;
15420
15421 mask_offset = str_pos + 1;
15422
15423 continue;
15424 }
15425 }
15426
15427 // reset the offset
15428
15429 mask_offset = 0;
15430
15431 mask[str_pos] = '\0';
15432
15433 switch (separator_cnt)
15434 {
15435 case 0:
15436 mp_reset_usr (mp_usr, 0);
15437
15438 custom_charset_1 = mask;
15439 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15440 break;
15441
15442 case 1:
15443 mp_reset_usr (mp_usr, 1);
15444
15445 custom_charset_2 = mask;
15446 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15447 break;
15448
15449 case 2:
15450 mp_reset_usr (mp_usr, 2);
15451
15452 custom_charset_3 = mask;
15453 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15454 break;
15455
15456 case 3:
15457 mp_reset_usr (mp_usr, 3);
15458
15459 custom_charset_4 = mask;
15460 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15461 break;
15462 }
15463
15464 mask = mask + str_pos + 1;
15465 }
15466 }
15467
15468 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15469 {
15470 if (maskpos > 0)
15471 {
15472 local_free (css_buf);
15473 local_free (data.root_css_buf);
15474 local_free (data.markov_css_buf);
15475
15476 local_free (masks[maskpos - 1]);
15477 }
15478
15479 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15480
15481 data.mask = mask;
15482 data.css_cnt = css_cnt;
15483 data.css_buf = css_buf;
15484
15485 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15486
15487 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15488
15489 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15490
15491 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15492 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15493
15494 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15495
15496 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15497
15498 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15499 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15500
15501 data.root_css_buf = root_css_buf;
15502 data.markov_css_buf = markov_css_buf;
15503
15504 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15505
15506 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15507
15508 local_free (root_table_buf);
15509 local_free (markov_table_buf);
15510
15511 // args
15512
15513 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15514 {
15515 hc_device_param_t *device_param = &data.devices_param[device_id];
15516
15517 device_param->kernel_params_mp[0] = &device_param->d_combs;
15518 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15519 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15520
15521 device_param->kernel_params_mp_buf64[3] = 0;
15522 device_param->kernel_params_mp_buf32[4] = css_cnt;
15523 device_param->kernel_params_mp_buf32[5] = 0;
15524 device_param->kernel_params_mp_buf32[6] = 0;
15525 device_param->kernel_params_mp_buf32[7] = 0;
15526
15527 if (attack_mode == ATTACK_MODE_HYBRID1)
15528 {
15529 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15530 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15531 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15532 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15533 }
15534 else if (attack_mode == ATTACK_MODE_HYBRID2)
15535 {
15536 device_param->kernel_params_mp_buf32[5] = 0;
15537 device_param->kernel_params_mp_buf32[6] = 0;
15538 device_param->kernel_params_mp_buf32[7] = 0;
15539 }
15540
15541 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15542 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15543 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15544
15545 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);
15546 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);
15547 }
15548 }
15549 else if (attack_mode == ATTACK_MODE_BF)
15550 {
15551 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15552
15553 if (increment)
15554 {
15555 for (uint i = 0; i < dictcnt; i++)
15556 {
15557 local_free (dictfiles[i]);
15558 }
15559
15560 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15561 {
15562 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15563
15564 if (l1_filename == NULL) break;
15565
15566 dictcnt++;
15567
15568 dictfiles[dictcnt - 1] = l1_filename;
15569 }
15570 }
15571 else
15572 {
15573 dictcnt++;
15574
15575 dictfiles[dictcnt - 1] = mask;
15576 }
15577
15578 if (dictcnt == 0)
15579 {
15580 log_error ("ERROR: Mask is too small");
15581
15582 return (-1);
15583 }
15584 }
15585 }
15586
15587 free (induction_dictionaries);
15588
15589 // induction_dictionaries_cnt = 0; // implied
15590
15591 if (attack_mode != ATTACK_MODE_BF)
15592 {
15593 if (keyspace == 0)
15594 {
15595 induction_dictionaries = scan_directory (induction_directory);
15596
15597 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15598 }
15599 }
15600
15601 if (induction_dictionaries_cnt)
15602 {
15603 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15604 }
15605
15606 /**
15607 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15608 */
15609 if (keyspace == 1)
15610 {
15611 if ((maskcnt > 1) || (dictcnt > 1))
15612 {
15613 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15614
15615 return (-1);
15616 }
15617 }
15618
15619 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15620 {
15621 char *subid = logfile_generate_subid ();
15622
15623 data.subid = subid;
15624
15625 logfile_sub_msg ("START");
15626
15627 data.devices_status = STATUS_INIT;
15628
15629 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15630 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15631 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15632
15633 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15634
15635 data.cpt_pos = 0;
15636
15637 data.cpt_start = time (NULL);
15638
15639 data.cpt_total = 0;
15640
15641 if (data.restore == 0)
15642 {
15643 rd->words_cur = skip;
15644
15645 skip = 0;
15646
15647 data.skip = 0;
15648 }
15649
15650 data.ms_paused = 0;
15651
15652 data.words_cur = rd->words_cur;
15653
15654 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15655 {
15656 hc_device_param_t *device_param = &data.devices_param[device_id];
15657
15658 device_param->speed_pos = 0;
15659
15660 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15661 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15662 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15663
15664 device_param->kernel_power = device_param->kernel_power_user;
15665 device_param->kernel_blocks = device_param->kernel_blocks_user;
15666
15667 device_param->outerloop_pos = 0;
15668 device_param->outerloop_left = 0;
15669 device_param->innerloop_pos = 0;
15670 device_param->innerloop_left = 0;
15671
15672 // some more resets:
15673
15674 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15675
15676 memset (device_param->pws_buf, 0, device_param->size_pws);
15677
15678 device_param->pw_cnt = 0;
15679 device_param->pws_cnt = 0;
15680
15681 device_param->words_off = 0;
15682 device_param->words_done = 0;
15683 }
15684
15685 data.kernel_blocks_div = 0;
15686
15687 // figure out some workload
15688
15689 if (attack_mode == ATTACK_MODE_STRAIGHT)
15690 {
15691 if (data.wordlist_mode == WL_MODE_FILE)
15692 {
15693 char *dictfile = NULL;
15694
15695 if (induction_dictionaries_cnt)
15696 {
15697 dictfile = induction_dictionaries[0];
15698 }
15699 else
15700 {
15701 dictfile = dictfiles[dictpos];
15702 }
15703
15704 data.dictfile = dictfile;
15705
15706 logfile_sub_string (dictfile);
15707
15708 for (uint i = 0; i < rp_files_cnt; i++)
15709 {
15710 logfile_sub_var_string ("rulefile", rp_files[i]);
15711 }
15712
15713 FILE *fd2 = fopen (dictfile, "rb");
15714
15715 if (fd2 == NULL)
15716 {
15717 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15718
15719 return (-1);
15720 }
15721
15722 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15723
15724 fclose (fd2);
15725
15726 if (data.words_cnt == 0)
15727 {
15728 if (data.devices_status == STATUS_CRACKED) break;
15729 if (data.devices_status == STATUS_ABORTED) break;
15730
15731 dictpos++;
15732
15733 continue;
15734 }
15735 }
15736 }
15737 else if (attack_mode == ATTACK_MODE_COMBI)
15738 {
15739 char *dictfile = data.dictfile;
15740 char *dictfile2 = data.dictfile2;
15741
15742 logfile_sub_string (dictfile);
15743 logfile_sub_string (dictfile2);
15744
15745 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15746 {
15747 FILE *fd2 = fopen (dictfile, "rb");
15748
15749 if (fd2 == NULL)
15750 {
15751 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15752
15753 return (-1);
15754 }
15755
15756 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15757
15758 fclose (fd2);
15759 }
15760 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15761 {
15762 FILE *fd2 = fopen (dictfile2, "rb");
15763
15764 if (fd2 == NULL)
15765 {
15766 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15767
15768 return (-1);
15769 }
15770
15771 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15772
15773 fclose (fd2);
15774 }
15775
15776 if (data.words_cnt == 0)
15777 {
15778 if (data.devices_status == STATUS_CRACKED) break;
15779 if (data.devices_status == STATUS_ABORTED) break;
15780
15781 dictpos++;
15782
15783 continue;
15784 }
15785 }
15786 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15787 {
15788 char *dictfile = NULL;
15789
15790 if (induction_dictionaries_cnt)
15791 {
15792 dictfile = induction_dictionaries[0];
15793 }
15794 else
15795 {
15796 dictfile = dictfiles[dictpos];
15797 }
15798
15799 data.dictfile = dictfile;
15800
15801 char *mask = data.mask;
15802
15803 logfile_sub_string (dictfile);
15804 logfile_sub_string (mask);
15805
15806 FILE *fd2 = fopen (dictfile, "rb");
15807
15808 if (fd2 == NULL)
15809 {
15810 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15811
15812 return (-1);
15813 }
15814
15815 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15816
15817 fclose (fd2);
15818
15819 if (data.words_cnt == 0)
15820 {
15821 if (data.devices_status == STATUS_CRACKED) break;
15822 if (data.devices_status == STATUS_ABORTED) break;
15823
15824 dictpos++;
15825
15826 continue;
15827 }
15828 }
15829 else if (attack_mode == ATTACK_MODE_BF)
15830 {
15831 local_free (css_buf);
15832 local_free (data.root_css_buf);
15833 local_free (data.markov_css_buf);
15834
15835 char *mask = dictfiles[dictpos];
15836
15837 logfile_sub_string (mask);
15838
15839 // base
15840
15841 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15842
15843 if (opts_type & OPTS_TYPE_PT_UNICODE)
15844 {
15845 uint css_cnt_unicode = css_cnt * 2;
15846
15847 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15848
15849 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15850 {
15851 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15852
15853 css_buf_unicode[j + 1].cs_buf[0] = 0;
15854 css_buf_unicode[j + 1].cs_len = 1;
15855 }
15856
15857 free (css_buf);
15858
15859 css_buf = css_buf_unicode;
15860 css_cnt = css_cnt_unicode;
15861 }
15862
15863 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15864
15865 uint mask_min = pw_min;
15866 uint mask_max = pw_max;
15867
15868 if (opts_type & OPTS_TYPE_PT_UNICODE)
15869 {
15870 mask_min *= 2;
15871 mask_max *= 2;
15872 }
15873
15874 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15875 {
15876 if (css_cnt < mask_min)
15877 {
15878 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15879 }
15880
15881 if (css_cnt > mask_max)
15882 {
15883 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15884 }
15885
15886 // skip to next mask
15887
15888 dictpos++;
15889
15890 rd->dictpos = dictpos;
15891
15892 logfile_sub_msg ("STOP");
15893
15894 continue;
15895 }
15896
15897 uint save_css_cnt = css_cnt;
15898
15899 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15900 {
15901 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15902 {
15903 uint salt_len = (uint) data.salts_buf[0].salt_len;
15904 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15905
15906 uint css_cnt_salt = css_cnt + salt_len;
15907
15908 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15909
15910 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15911
15912 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15913 {
15914 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15915 css_buf_salt[j].cs_len = 1;
15916 }
15917
15918 free (css_buf);
15919
15920 css_buf = css_buf_salt;
15921 css_cnt = css_cnt_salt;
15922 }
15923 }
15924
15925 data.mask = mask;
15926 data.css_cnt = css_cnt;
15927 data.css_buf = css_buf;
15928
15929 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15930
15931 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15932
15933 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15934
15935 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15936
15937 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15938 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15939
15940 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15941
15942 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15943
15944 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15945 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15946
15947 data.root_css_buf = root_css_buf;
15948 data.markov_css_buf = markov_css_buf;
15949
15950 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15951
15952 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15953
15954 local_free (root_table_buf);
15955 local_free (markov_table_buf);
15956
15957 // copy + args
15958
15959 uint css_cnt_l = css_cnt;
15960 uint css_cnt_r;
15961
15962 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15963 {
15964 if (save_css_cnt < 6)
15965 {
15966 css_cnt_r = 1;
15967 }
15968 else if (save_css_cnt == 6)
15969 {
15970 css_cnt_r = 2;
15971 }
15972 else
15973 {
15974 if (opts_type & OPTS_TYPE_PT_UNICODE)
15975 {
15976 if (save_css_cnt == 8 || save_css_cnt == 10)
15977 {
15978 css_cnt_r = 2;
15979 }
15980 else
15981 {
15982 css_cnt_r = 4;
15983 }
15984 }
15985 else
15986 {
15987 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15988 {
15989 css_cnt_r = 3;
15990 }
15991 else
15992 {
15993 css_cnt_r = 4;
15994 }
15995 }
15996 }
15997 }
15998 else
15999 {
16000 css_cnt_r = 1;
16001
16002 /* unfinished code?
16003 int sum = css_buf[css_cnt_r - 1].cs_len;
16004
16005 for (uint i = 1; i < 4 && i < css_cnt; i++)
16006 {
16007 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16008
16009 css_cnt_r++;
16010
16011 sum *= css_buf[css_cnt_r - 1].cs_len;
16012 }
16013 */
16014 }
16015
16016 css_cnt_l -= css_cnt_r;
16017
16018 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16019
16020 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16021 {
16022 hc_device_param_t *device_param = &data.devices_param[device_id];
16023
16024 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16025 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16026 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16027
16028 device_param->kernel_params_mp_l_buf64[3] = 0;
16029 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16030 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16031 device_param->kernel_params_mp_l_buf32[6] = 0;
16032 device_param->kernel_params_mp_l_buf32[7] = 0;
16033 device_param->kernel_params_mp_l_buf32[8] = 0;
16034
16035 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16036 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16037 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16038 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16039
16040 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16041 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16042 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16043
16044 device_param->kernel_params_mp_r_buf64[3] = 0;
16045 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16046 device_param->kernel_params_mp_r_buf32[5] = 0;
16047 device_param->kernel_params_mp_r_buf32[6] = 0;
16048 device_param->kernel_params_mp_r_buf32[7] = 0;
16049
16050 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]);
16051 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]);
16052 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]);
16053
16054 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]);
16055 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]);
16056 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]);
16057
16058 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);
16059 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);
16060 }
16061 }
16062
16063 uint64_t words_base = data.words_cnt;
16064
16065 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16066 {
16067 if (data.kernel_rules_cnt)
16068 {
16069 words_base /= data.kernel_rules_cnt;
16070 }
16071 }
16072 else if (data.attack_kern == ATTACK_KERN_COMBI)
16073 {
16074 if (data.combs_cnt)
16075 {
16076 words_base /= data.combs_cnt;
16077 }
16078 }
16079 else if (data.attack_kern == ATTACK_KERN_BF)
16080 {
16081 if (data.bfs_cnt)
16082 {
16083 words_base /= data.bfs_cnt;
16084 }
16085 }
16086
16087 data.words_base = words_base;
16088
16089 if (keyspace == 1)
16090 {
16091 log_info ("%llu", (unsigned long long int) words_base);
16092
16093 return (0);
16094 }
16095
16096 if (data.words_cur > data.words_base)
16097 {
16098 log_error ("ERROR: restore value greater keyspace");
16099
16100 return (-1);
16101 }
16102
16103 if (data.words_cur)
16104 {
16105 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16106 {
16107 for (uint i = 0; i < data.salts_cnt; i++)
16108 {
16109 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16110 }
16111 }
16112 else if (data.attack_kern == ATTACK_KERN_COMBI)
16113 {
16114 for (uint i = 0; i < data.salts_cnt; i++)
16115 {
16116 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16117 }
16118 }
16119 else if (data.attack_kern == ATTACK_KERN_BF)
16120 {
16121 for (uint i = 0; i < data.salts_cnt; i++)
16122 {
16123 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16124 }
16125 }
16126 }
16127
16128 /*
16129 * Inform user about possible slow speeds
16130 */
16131
16132 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16133 {
16134 if (data.words_base < kernel_blocks_all)
16135 {
16136 if (quiet == 0)
16137 {
16138 log_info ("");
16139 log_info ("ATTENTION!");
16140 log_info (" The wordlist or mask you are using is too small.");
16141 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16142 log_info (" The cracking speed will drop.");
16143 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16144 log_info ("");
16145 }
16146 }
16147 }
16148
16149 /*
16150 * Update loopback file
16151 */
16152
16153 if (loopback == 1)
16154 {
16155 time_t now;
16156
16157 time (&now);
16158
16159 uint random_num = get_random_num (0, 9999);
16160
16161 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16162
16163 data.loopback_file = loopback_file;
16164 }
16165
16166 /*
16167 * Update dictionary statistic
16168 */
16169
16170 if (keyspace == 0)
16171 {
16172 dictstat_fp = fopen (dictstat, "wb");
16173
16174 if (dictstat_fp)
16175 {
16176 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16177
16178 fclose (dictstat_fp);
16179 }
16180 }
16181
16182 data.devices_status = STATUS_RUNNING;
16183
16184 if (initial_restore_done == 0)
16185 {
16186 if (data.restore_disable == 0) cycle_restore ();
16187
16188 initial_restore_done = 1;
16189 }
16190
16191 hc_timer_set (&data.timer_running);
16192
16193 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16194 {
16195 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16196 {
16197 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16198 if (quiet == 0) fflush (stdout);
16199 }
16200 }
16201 else if (wordlist_mode == WL_MODE_STDIN)
16202 {
16203 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16204 if (data.quiet == 0) log_info ("");
16205 }
16206
16207 time_t runtime_start;
16208
16209 time (&runtime_start);
16210
16211 data.runtime_start = runtime_start;
16212
16213 /**
16214 * create cracker threads
16215 */
16216
16217 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16218
16219 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16220 {
16221 hc_device_param_t *device_param = &devices_param[device_id];
16222
16223 device_param->device_id = device_id;
16224
16225 if (wordlist_mode == WL_MODE_STDIN)
16226 {
16227 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16228 }
16229 else
16230 {
16231 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16232 }
16233 }
16234
16235 // wait for crack threads to exit
16236
16237 hc_thread_wait (devices_cnt, c_threads);
16238
16239 local_free (c_threads);
16240
16241 data.restore = 0;
16242
16243 // finalize task
16244
16245 logfile_sub_var_uint ("status-after-work", data.devices_status);
16246
16247 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16248
16249 if (data.devices_status == STATUS_CRACKED) break;
16250 if (data.devices_status == STATUS_ABORTED) break;
16251
16252 if (data.devices_status == STATUS_BYPASS)
16253 {
16254 data.devices_status = STATUS_RUNNING;
16255 }
16256
16257 if (induction_dictionaries_cnt)
16258 {
16259 unlink (induction_dictionaries[0]);
16260 }
16261
16262 free (induction_dictionaries);
16263
16264 if (attack_mode != ATTACK_MODE_BF)
16265 {
16266 induction_dictionaries = scan_directory (induction_directory);
16267
16268 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16269 }
16270
16271 if (benchmark == 0)
16272 {
16273 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16274 {
16275 if (quiet == 0) clear_prompt ();
16276
16277 if (quiet == 0) log_info ("");
16278
16279 if (status == 1)
16280 {
16281 status_display ();
16282 }
16283 else
16284 {
16285 if (quiet == 0) status_display ();
16286 }
16287
16288 if (quiet == 0) log_info ("");
16289 }
16290 }
16291
16292 if (attack_mode == ATTACK_MODE_BF)
16293 {
16294 dictpos++;
16295
16296 rd->dictpos = dictpos;
16297 }
16298 else
16299 {
16300 if (induction_dictionaries_cnt)
16301 {
16302 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16303 }
16304 else
16305 {
16306 dictpos++;
16307
16308 rd->dictpos = dictpos;
16309 }
16310 }
16311
16312 time_t runtime_stop;
16313
16314 time (&runtime_stop);
16315
16316 data.runtime_stop = runtime_stop;
16317
16318 logfile_sub_uint (runtime_start);
16319 logfile_sub_uint (runtime_stop);
16320
16321 logfile_sub_msg ("STOP");
16322
16323 global_free (subid);
16324 }
16325
16326 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16327
16328 if (data.devices_status == STATUS_CRACKED) break;
16329 if (data.devices_status == STATUS_ABORTED) break;
16330 if (data.devices_status == STATUS_QUIT) break;
16331
16332 if (data.devices_status == STATUS_BYPASS)
16333 {
16334 data.devices_status = STATUS_RUNNING;
16335 }
16336 }
16337
16338 // 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
16339
16340 if (attack_mode == ATTACK_MODE_STRAIGHT)
16341 {
16342 if (data.wordlist_mode == WL_MODE_FILE)
16343 {
16344 if (data.dictfile == NULL)
16345 {
16346 if (dictfiles != NULL)
16347 {
16348 data.dictfile = dictfiles[0];
16349
16350 hc_timer_set (&data.timer_running);
16351 }
16352 }
16353 }
16354 }
16355 // NOTE: combi is okay because it is already set beforehand
16356 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16357 {
16358 if (data.dictfile == NULL)
16359 {
16360 if (dictfiles != NULL)
16361 {
16362 hc_timer_set (&data.timer_running);
16363
16364 data.dictfile = dictfiles[0];
16365 }
16366 }
16367 }
16368 else if (attack_mode == ATTACK_MODE_BF)
16369 {
16370 if (data.mask == NULL)
16371 {
16372 hc_timer_set (&data.timer_running);
16373
16374 data.mask = masks[0];
16375 }
16376 }
16377
16378 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16379 {
16380 data.devices_status = STATUS_EXHAUSTED;
16381 }
16382
16383 // if cracked / aborted remove last induction dictionary
16384
16385 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16386 {
16387 struct stat induct_stat;
16388
16389 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16390 {
16391 unlink (induction_dictionaries[file_pos]);
16392 }
16393 }
16394
16395 // wait for non-interactive threads
16396
16397 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16398 {
16399 hc_thread_wait (1, &ni_threads[thread_idx]);
16400 }
16401
16402 local_free (ni_threads);
16403
16404 // wait for interactive threads
16405
16406 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16407 {
16408 hc_thread_wait (1, &i_thread);
16409 }
16410
16411 // we dont need restore file anymore
16412 if (data.restore_disable == 0)
16413 {
16414 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16415 {
16416 unlink (eff_restore_file);
16417 unlink (new_restore_file);
16418 }
16419 else
16420 {
16421 cycle_restore ();
16422 }
16423 }
16424
16425 // finally save left hashes
16426
16427 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16428 {
16429 save_hash ();
16430 }
16431
16432 /**
16433 * Clean up
16434 */
16435
16436 if (benchmark == 1)
16437 {
16438 status_benchmark ();
16439
16440 log_info ("");
16441 }
16442 else
16443 {
16444 if (quiet == 0) clear_prompt ();
16445
16446 if (quiet == 0) log_info ("");
16447
16448 if (status == 1)
16449 {
16450 status_display ();
16451 }
16452 else
16453 {
16454 if (quiet == 0) status_display ();
16455 }
16456
16457 if (quiet == 0) log_info ("");
16458 }
16459
16460 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16461 {
16462 hc_device_param_t *device_param = &data.devices_param[device_id];
16463
16464 local_free (device_param->result);
16465
16466 local_free (device_param->pw_caches);
16467
16468 local_free (device_param->combs_buf);
16469
16470 local_free (device_param->hooks_buf);
16471
16472 local_free (device_param->device_name);
16473
16474 local_free (device_param->device_name_chksum);
16475
16476 local_free (device_param->device_version);
16477
16478 local_free (device_param->driver_version);
16479
16480 if (device_param->pws_buf) myfree (device_param->pws_buf);
16481 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16482 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16483 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16484 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16485 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16486 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16487 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16488 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16489 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16490 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16491 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16492 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16493 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16494 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16495 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16496 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16497 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16498 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16499 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16500 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16501 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16502 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16503 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16504 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16505 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16506 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16507 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16508 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16509
16510 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16511 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16512 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16513 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16514 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16515 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16516 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16517 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16518 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16519 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16520 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16521 if (device_param->kernel_weak) hc_clReleaseKernel (device_param->kernel_weak);
16522
16523 if (device_param->program) hc_clReleaseProgram (device_param->program);
16524 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16525 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16526 if (device_param->program_weak) hc_clReleaseProgram (device_param->program_weak);
16527
16528 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16529 if (device_param->context) hc_clReleaseContext (device_param->context);
16530 }
16531
16532 // reset default fan speed
16533
16534 if (gpu_temp_disable == 0)
16535 {
16536 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16537 {
16538 hc_thread_mutex_lock (mux_adl);
16539
16540 for (uint i = 0; i < data.devices_cnt; i++)
16541 {
16542 if (data.hm_device[i].fan_supported == 1)
16543 {
16544 int fanspeed = temp_retain_fanspeed_value[i];
16545
16546 if (fanspeed == -1) continue;
16547
16548 int rc = hm_set_fanspeed_with_device_id_amd (i, fanspeed);
16549
16550 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
16551 }
16552 }
16553
16554 hc_thread_mutex_unlock (mux_adl);
16555 }
16556 }
16557
16558 // reset power tuning
16559
16560 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16561 {
16562 hc_thread_mutex_lock (mux_adl);
16563
16564 for (uint i = 0; i < data.devices_cnt; i++)
16565 {
16566 if (data.hm_device[i].od_version == 6)
16567 {
16568 // check powertune capabilities first, if not available then skip device
16569
16570 int powertune_supported = 0;
16571
16572 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
16573 {
16574 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16575
16576 return (-1);
16577 }
16578
16579 if (powertune_supported != 0)
16580 {
16581 // powercontrol settings
16582
16583 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, od_power_control_status[i])) != ADL_OK)
16584 {
16585 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16586
16587 return (-1);
16588 }
16589
16590 // clocks
16591
16592 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16593
16594 performance_state->iNumberOfPerformanceLevels = 2;
16595
16596 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
16597 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
16598 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
16599 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
16600
16601 if ((hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16602 {
16603 log_info ("ERROR: Failed to restore ADL performance state");
16604
16605 return (-1);
16606 }
16607
16608 local_free (performance_state);
16609 }
16610 }
16611 }
16612
16613 hc_thread_mutex_unlock (mux_adl);
16614 }
16615
16616 if (gpu_temp_disable == 0)
16617 {
16618 if (vendor_id == VENDOR_ID_NV)
16619 {
16620 #ifdef LINUX
16621 hc_NVML_nvmlShutdown (data.hm_dll);
16622 #endif
16623
16624 #ifdef WIN
16625 NvAPI_Unload ();
16626 #endif
16627 }
16628
16629 if (vendor_id == VENDOR_ID_AMD)
16630 {
16631 hc_ADL_Main_Control_Destroy (data.hm_dll);
16632
16633 hm_close (data.hm_dll);
16634 }
16635
16636 #ifdef LINUX
16637 if (vendor_id == VENDOR_ID_NV)
16638 {
16639 hm_close (data.hm_dll);
16640 }
16641 #endif
16642 }
16643
16644 // free memory
16645
16646 local_free (masks);
16647
16648 local_free (dictstat_base);
16649
16650 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16651 {
16652 pot_t *pot_ptr = &pot[pot_pos];
16653
16654 hash_t *hash = &pot_ptr->hash;
16655
16656 local_free (hash->digest);
16657
16658 if (isSalted)
16659 {
16660 local_free (hash->salt);
16661 }
16662 }
16663
16664 local_free (pot);
16665
16666 local_free (all_kernel_rules_cnt);
16667 local_free (all_kernel_rules_buf);
16668
16669 local_free (wl_data->buf);
16670 local_free (wl_data);
16671
16672 local_free (bitmap_s1_a);
16673 local_free (bitmap_s1_b);
16674 local_free (bitmap_s1_c);
16675 local_free (bitmap_s1_d);
16676 local_free (bitmap_s2_a);
16677 local_free (bitmap_s2_b);
16678 local_free (bitmap_s2_c);
16679 local_free (bitmap_s2_d);
16680
16681 local_free (temp_retain_fanspeed_value);
16682 local_free (od_clock_mem_status);
16683 local_free (od_power_control_status);
16684
16685 global_free (devices_param);
16686
16687 global_free (kernel_rules_buf);
16688
16689 global_free (root_css_buf);
16690 global_free (markov_css_buf);
16691
16692 global_free (digests_buf);
16693 global_free (digests_shown);
16694 global_free (digests_shown_tmp);
16695
16696 global_free (salts_buf);
16697 global_free (salts_shown);
16698
16699 global_free (esalts_buf);
16700
16701 global_free (words_progress_done);
16702 global_free (words_progress_rejected);
16703 global_free (words_progress_restored);
16704
16705 if (pot_fp) fclose (pot_fp);
16706
16707 if (data.devices_status == STATUS_QUIT) break;
16708 }
16709
16710 // destroy others mutex
16711
16712 hc_thread_mutex_delete (mux_dispatcher);
16713 hc_thread_mutex_delete (mux_counter);
16714 hc_thread_mutex_delete (mux_display);
16715 hc_thread_mutex_delete (mux_adl);
16716
16717 // free memory
16718
16719 local_free (eff_restore_file);
16720 local_free (new_restore_file);
16721
16722 local_free (rd);
16723
16724 // loopback
16725
16726 local_free (loopback_file);
16727
16728 if (loopback == 1) unlink (loopback_file);
16729
16730 // induction directory
16731
16732 if (induction_dir == NULL)
16733 {
16734 if (attack_mode != ATTACK_MODE_BF)
16735 {
16736 if (rmdir (induction_directory) == -1)
16737 {
16738 if (errno == ENOENT)
16739 {
16740 // good, we can ignore
16741 }
16742 else if (errno == ENOTEMPTY)
16743 {
16744 // good, we can ignore
16745 }
16746 else
16747 {
16748 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16749
16750 return (-1);
16751 }
16752 }
16753
16754 local_free (induction_directory);
16755 }
16756 }
16757
16758 // outfile-check directory
16759
16760 if (outfile_check_dir == NULL)
16761 {
16762 if (rmdir (outfile_check_directory) == -1)
16763 {
16764 if (errno == ENOENT)
16765 {
16766 // good, we can ignore
16767 }
16768 else if (errno == ENOTEMPTY)
16769 {
16770 // good, we can ignore
16771 }
16772 else
16773 {
16774 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16775
16776 return (-1);
16777 }
16778 }
16779
16780 local_free (outfile_check_directory);
16781 }
16782
16783 time_t proc_stop;
16784
16785 time (&proc_stop);
16786
16787 logfile_top_uint (proc_start);
16788 logfile_top_uint (proc_stop);
16789
16790 logfile_top_msg ("STOP");
16791
16792 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16793 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16794
16795 if (data.devices_status == STATUS_ABORTED) return 2;
16796 if (data.devices_status == STATUS_QUIT) return 2;
16797 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16798 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16799 if (data.devices_status == STATUS_CRACKED) return 0;
16800
16801 return -1;
16802 }
Hashcat additions to support pwdhash