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