projects / hashcat.git / blob
? search:


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