projects / hashcat.git / blob
? search:


8b639be6e591014a7eba6e70509490c7d40dd454
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Author......: Jens Steube <jens.steube@gmail.com>
3 * License.....: MIT
4 */
5
6 #include <common.h>
7 #include <shared.h>
8 #include <rp_kernel_on_cpu.h>
9 #include <getopt.h>
10
11 const char *PROGNAME = "oclHashcat";
12 const char *VERSION_TXT = "2.10";
13 const uint VERSION_BIN = 210;
14 const uint RESTORE_MIN = 210;
15
16 #define INCR_RULES 10000
17 #define INCR_SALTS 100000
18 #define INCR_MASKS 1000
19 #define INCR_POT 1000
20
21 #define USAGE 0
22 #define VERSION 0
23 #define QUIET 0
24 #define MARKOV_THRESHOLD 0
25 #define MARKOV_DISABLE 0
26 #define MARKOV_CLASSIC 0
27 #define BENCHMARK 0
28 #define BENCHMARK_MODE 1
29 #define RESTORE 0
30 #define RESTORE_TIMER 60
31 #define RESTORE_DISABLE 0
32 #define STATUS 0
33 #define STATUS_TIMER 10
34 #define STATUS_AUTOMAT 0
35 #define LOOPBACK 0
36 #define WEAK_HASH_THRESHOLD 100
37 #define SHOW 0
38 #define LEFT 0
39 #define USERNAME 0
40 #define REMOVE 0
41 #define REMOVE_TIMER 60
42 #define SKIP 0
43 #define LIMIT 0
44 #define KEYSPACE 0
45 #define POTFILE_DISABLE 0
46 #define DEBUG_MODE 0
47 #define RP_GEN 0
48 #define RP_GEN_FUNC_MIN 1
49 #define RP_GEN_FUNC_MAX 4
50 #define RP_GEN_SEED 0
51 #define RULE_BUF_L ":"
52 #define RULE_BUF_R ":"
53 #define FORCE 0
54 #define RUNTIME 0
55 #define HEX_CHARSET 0
56 #define HEX_SALT 0
57 #define HEX_WORDLIST 0
58 #define OUTFILE_FORMAT 3
59 #define OUTFILE_AUTOHEX 1
60 #define OUTFILE_CHECK_TIMER 5
61 #define ATTACK_MODE 0
62 #define HASH_MODE 0
63 #define SEGMENT_SIZE 32
64 #define INCREMENT 0
65 #define INCREMENT_MIN 1
66 #define INCREMENT_MAX PW_MAX
67 #define SEPARATOR ':'
68 #define BITMAP_MIN 16
69 #define BITMAP_MAX 24
70 #define GPU_TEMP_DISABLE 0
71 #define GPU_TEMP_ABORT 90
72 #define GPU_TEMP_RETAIN 80
73 #define WORKLOAD_PROFILE 2
74 #define KERNEL_ACCEL 0
75 #define KERNEL_LOOPS 0
76 #define KERNEL_RULES 1024
77 #define KERNEL_COMBS 1024
78 #define KERNEL_BFS 1024
79 #define KERNEL_THREADS 64
80 #define POWERTUNE_ENABLE 0
81 #define LOGFILE_DISABLE 0
82 #define SCRYPT_TMTO 0
83
84 #define WL_MODE_STDIN 1
85 #define WL_MODE_FILE 2
86 #define WL_MODE_MASK 3
87
88 #define HL_MODE_FILE 4
89 #define HL_MODE_ARG 5
90
91 #define HLFMT_HASHCAT 0
92 #define HLFMT_PWDUMP 1
93 #define HLFMT_PASSWD 2
94 #define HLFMT_SHADOW 3
95 #define HLFMT_DCC 4
96 #define HLFMT_DCC2 5
97 #define HLFMT_NETNTLM1 7
98 #define HLFMT_NETNTLM2 8
99 #define HLFMT_NSLDAP 9
100 #define HLFMT_NSLDAPS 10
101 #define HLFMTS_CNT 11
102
103 #define ATTACK_MODE_STRAIGHT 0
104 #define ATTACK_MODE_COMBI 1
105 #define ATTACK_MODE_TOGGLE 2
106 #define ATTACK_MODE_BF 3
107 #define ATTACK_MODE_PERM 4
108 #define ATTACK_MODE_TABLE 5
109 #define ATTACK_MODE_HYBRID1 6
110 #define ATTACK_MODE_HYBRID2 7
111 #define ATTACK_MODE_NONE 100
112
113 #define ATTACK_KERN_STRAIGHT 0
114 #define ATTACK_KERN_COMBI 1
115 #define ATTACK_KERN_BF 3
116 #define ATTACK_KERN_NONE 100
117
118 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
119 #define ATTACK_EXEC_INSIDE_KERNEL 11
120
121 #define COMBINATOR_MODE_BASE_LEFT 10001
122 #define COMBINATOR_MODE_BASE_RIGHT 10002
123
124 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
125 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
126
127 #define MAX_CUT_TRIES 4
128
129 #define MAX_DICTSTAT 10000
130
131 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
132
133 #define global_free(attr) \
134 { \
135 myfree ((void *) data.attr); \
136 \
137 data.attr = NULL; \
138 }
139
140 #define local_free(attr) \
141 { \
142 myfree ((void *) attr); \
143 \
144 attr = NULL; \
145 }
146
147 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
148 {
149 900,
150 0,
151 5100,
152 100,
153 1400,
154 10800,
155 1700,
156 5000,
157 10100,
158 6000,
159 6100,
160 6900,
161 11700,
162 11800,
163 400,
164 8900,
165 11900,
166 12000,
167 10900,
168 12100,
169 23,
170 2500,
171 5300,
172 5400,
173 5500,
174 5600,
175 7300,
176 7500,
177 8300,
178 11100,
179 11200,
180 11400,
181 121,
182 2611,
183 2711,
184 2811,
185 8400,
186 11,
187 2612,
188 7900,
189 21,
190 11000,
191 124,
192 10000,
193 3711,
194 7600,
195 12,
196 131,
197 132,
198 1731,
199 200,
200 300,
201 3100,
202 112,
203 12300,
204 8000,
205 141,
206 1441,
207 1600,
208 12600,
209 1421,
210 101,
211 111,
212 1711,
213 3000,
214 1000,
215 1100,
216 2100,
217 12800,
218 1500,
219 12400,
220 500,
221 3200,
222 7400,
223 1800,
224 122,
225 1722,
226 7100,
227 6300,
228 6700,
229 6400,
230 6500,
231 2400,
232 2410,
233 5700,
234 9200,
235 9300,
236 22,
237 501,
238 5800,
239 8100,
240 8500,
241 7200,
242 9900,
243 7700,
244 7800,
245 10300,
246 8600,
247 8700,
248 9100,
249 133,
250 11600,
251 12500,
252 13000,
253 6211,
254 6221,
255 6231,
256 6241,
257 8800,
258 12900,
259 12200,
260 9700,
261 9710,
262 9800,
263 9810,
264 9400,
265 9500,
266 9600,
267 10400,
268 10410,
269 10500,
270 10600,
271 10700,
272 9000,
273 5200,
274 6800,
275 6600,
276 8200,
277 11300,
278 12700
279 };
280
281 /**
282 * types
283 */
284
285 static void (*get_next_word_func) (char *, uint32_t, uint32_t *, uint32_t *);
286
287 /**
288 * globals
289 */
290
291 static unsigned int full01 = 0x01010101;
292 static unsigned int full80 = 0x80808080;
293
294 int SUPPRESS_OUTPUT = 0;
295
296 hc_thread_mutex_t mux_adl;
297 hc_thread_mutex_t mux_counter;
298 hc_thread_mutex_t mux_dispatcher;
299 hc_thread_mutex_t mux_display;
300
301 hc_global_data_t data;
302
303 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
304
305 const char *USAGE_MINI[] =
306 {
307 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
308 "",
309 "Try --help for more help.",
310 NULL
311 };
312
313 const char *USAGE_BIG[] =
314 {
315 "%s, advanced password recovery",
316 "",
317 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
318 "",
319 "=======",
320 "Options",
321 "=======",
322 "",
323 "* General:",
324 "",
325 " -m, --hash-type=NUM Hash-type, see references below",
326 " -a, --attack-mode=NUM Attack-mode, see references below",
327 " -V, --version Print version",
328 " -h, --help Print help",
329 " --quiet Suppress output",
330 "",
331 "* Benchmark:",
332 "",
333 " -b, --benchmark Run benchmark",
334 " --benchmark-mode=NUM Benchmark-mode, see references below",
335 "",
336 "* Misc:",
337 "",
338 " --hex-charset Assume charset is given in hex",
339 " --hex-salt Assume salt is given in hex",
340 " --hex-wordlist Assume words in wordlist is given in hex",
341 " --force Ignore warnings",
342 " --status Enable automatic update of the status-screen",
343 " --status-timer=NUM Seconds between status-screen update",
344 " --status-automat Display the status view in a machine readable format",
345 " --loopback Add new plains to induct directory",
346 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
347 "",
348 "* Markov:",
349 "",
350 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
351 " --markov-disable Disables markov-chains, emulates classic brute-force",
352 " --markov-classic Enables classic markov-chains, no per-position enhancement",
353 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
354 "",
355 "* Session:",
356 "",
357 " --runtime=NUM Abort session after NUM seconds of runtime",
358 " --session=STR Define specific session name",
359 " --restore Restore session from --session",
360 " --restore-disable Do not write restore file",
361 "",
362 "* Files:",
363 "",
364 " -o, --outfile=FILE Define outfile for recovered hash",
365 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
366 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
367 " --outfile-check-timer=NUM Seconds between outfile checks",
368 " -p, --separator=CHAR Separator char for hashlists and outfile",
369 " --show Show cracked passwords only",
370 " --left Show un-cracked passwords only",
371 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
372 " --remove Enable remove of hash once it is cracked",
373 " --remove-timer=NUM Update input hash file each NUM seconds",
374 " --potfile-disable Do not write potfile",
375 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
376 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
377 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
378 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
379 " --logfile-disable Disable the logfile",
380 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
381 "",
382 "* Resources:",
383 "",
384 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
385 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
386 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
387 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
388 " --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 uint64_t speed_cnt = 0;
747 float speed_ms = 0;
748
749 for (int i = 0; i < SPEED_CACHE; i++)
750 {
751 float rec_ms;
752
753 hc_timer_get (device_param->speed_rec[i], rec_ms);
754
755 if (rec_ms > SPEED_MAXAGE) continue;
756
757 speed_cnt += device_param->speed_cnt[i];
758 speed_ms += device_param->speed_ms[i];
759 }
760
761 speed_cnt /= SPEED_CACHE;
762 speed_ms /= SPEED_CACHE;
763
764 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
765 }
766
767 /**
768 * words_cur
769 */
770
771 uint64_t words_cur = get_lowest_words_done ();
772
773 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
774
775 /**
776 * counter
777 */
778
779 uint salts_left = data.salts_cnt - data.salts_done;
780
781 if (salts_left == 0) salts_left = 1;
782
783 uint64_t progress_total = data.words_cnt * salts_left;
784
785 uint64_t all_done = 0;
786 uint64_t all_rejected = 0;
787 uint64_t all_restored = 0;
788
789 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
790 {
791 if (salts_left > 1)
792 {
793 // otherwise the final cracked status shows 0/XXX progress
794
795 if (data.salts_shown[salt_pos] == 1) continue;
796 }
797
798 all_done += data.words_progress_done[salt_pos];
799 all_rejected += data.words_progress_rejected[salt_pos];
800 all_restored += data.words_progress_restored[salt_pos];
801 }
802
803 uint64_t progress_cur = all_restored + all_done + all_rejected;
804 uint64_t progress_end = progress_total;
805
806 uint64_t progress_skip = 0;
807
808 if (data.skip)
809 {
810 progress_skip = MIN (data.skip, data.words_base) * salts_left;
811
812 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
813 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
814 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
815 }
816
817 if (data.limit)
818 {
819 progress_end = MIN (data.limit, data.words_base) * salts_left;
820
821 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
822 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
823 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
824 }
825
826 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
827 uint64_t progress_end_relative_skip = progress_end - progress_skip;
828
829 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
830
831 /**
832 * cracks
833 */
834
835 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
836 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
837
838 /**
839 * temperature
840 */
841
842 if (data.gpu_temp_disable == 0)
843 {
844 fprintf (out, "TEMP\t");
845
846 hc_thread_mutex_lock (mux_adl);
847
848 for (uint i = 0; i < data.devices_cnt; i++)
849 {
850 int temp = hm_get_temperature_with_device_id (i);
851
852 fprintf (out, "%d\t", temp);
853 }
854
855 hc_thread_mutex_unlock (mux_adl);
856 }
857
858 #ifdef _WIN
859 fputc ('\r', out);
860 fputc ('\n', out);
861 #endif
862
863 #ifdef _POSIX
864 fputc ('\n', out);
865 #endif
866
867 fflush (out);
868 }
869
870 void status_display ()
871 {
872 if (data.devices_status == STATUS_INIT) return;
873 if (data.devices_status == STATUS_STARTING) return;
874 if (data.devices_status == STATUS_BYPASS) return;
875
876 if (data.status_automat == 1)
877 {
878 status_display_automat ();
879
880 return;
881 }
882
883 char tmp_buf[1000];
884
885 uint tmp_len = 0;
886
887 log_info ("Session.Name...: %s", data.session);
888
889 char *status_type = strstatus (data.devices_status);
890
891 uint hash_mode = data.hash_mode;
892
893 char *hash_type = strhashtype (hash_mode); // not a bug
894
895 log_info ("Status.........: %s", status_type);
896
897 /**
898 * show rules
899 */
900
901 if (data.rp_files_cnt)
902 {
903 uint i;
904
905 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
906 {
907 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
908 }
909
910 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
911
912 log_info ("Rules.Type.....: %s", tmp_buf);
913
914 tmp_len = 0;
915 }
916
917 if (data.rp_gen)
918 {
919 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
920
921 if (data.rp_gen_seed)
922 {
923 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
924 }
925 }
926
927 /**
928 * show input
929 */
930
931 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
932 {
933 if (data.wordlist_mode == WL_MODE_FILE)
934 {
935 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
936 }
937 else if (data.wordlist_mode == WL_MODE_STDIN)
938 {
939 log_info ("Input.Mode.....: Pipe");
940 }
941 }
942 else if (data.attack_mode == ATTACK_MODE_COMBI)
943 {
944 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
945 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
946 }
947 else if (data.attack_mode == ATTACK_MODE_BF)
948 {
949 char *mask = data.mask;
950
951 if (mask != NULL)
952 {
953 uint mask_len = data.css_cnt;
954
955 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
956
957 if (mask_len > 0)
958 {
959 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
960 {
961 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
962 {
963 mask_len -= data.salts_buf[0].salt_len;
964 }
965 }
966
967 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
968
969 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
970 }
971
972 if (data.maskcnt > 1)
973 {
974 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
975
976 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
977 }
978
979 log_info ("Input.Mode.....: %s", tmp_buf);
980 }
981
982 tmp_len = 0;
983 }
984 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
985 {
986 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
987 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
988 }
989 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
990 {
991 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
992 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
993 }
994
995 if (data.digests_cnt == 1)
996 {
997 if (data.hash_mode == 2500)
998 {
999 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1000
1001 uint pke[25];
1002
1003 char *pke_ptr = (char *) pke;
1004
1005 for (uint i = 0; i < 25; i++)
1006 {
1007 pke[i] = byte_swap_32 (wpa->pke[i]);
1008 }
1009
1010 char mac1[6];
1011 char mac2[6];
1012
1013 memcpy (mac1, pke_ptr + 23, 6);
1014 memcpy (mac2, pke_ptr + 29, 6);
1015
1016 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1017 (char *) data.salts_buf[0].salt_buf,
1018 mac1[0] & 0xff,
1019 mac1[1] & 0xff,
1020 mac1[2] & 0xff,
1021 mac1[3] & 0xff,
1022 mac1[4] & 0xff,
1023 mac1[5] & 0xff,
1024 mac2[0] & 0xff,
1025 mac2[1] & 0xff,
1026 mac2[2] & 0xff,
1027 mac2[3] & 0xff,
1028 mac2[4] & 0xff,
1029 mac2[5] & 0xff);
1030 }
1031 else if (data.hash_mode == 5200)
1032 {
1033 log_info ("Hash.Target....: File (%s)", data.hashfile);
1034 }
1035 else if (data.hash_mode == 9000)
1036 {
1037 log_info ("Hash.Target....: File (%s)", data.hashfile);
1038 }
1039 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1040 {
1041 log_info ("Hash.Target....: File (%s)", data.hashfile);
1042 }
1043 else
1044 {
1045 char out_buf[4096];
1046
1047 ascii_digest (out_buf, 0, 0);
1048
1049 // limit length
1050 if (strlen (out_buf) > 40)
1051 {
1052 out_buf[41] = '.';
1053 out_buf[42] = '.';
1054 out_buf[43] = '.';
1055 out_buf[44] = 0;
1056 }
1057
1058 log_info ("Hash.Target....: %s", out_buf);
1059 }
1060 }
1061 else
1062 {
1063 if (data.hash_mode == 3000)
1064 {
1065 char out_buf1[4096];
1066 char out_buf2[4096];
1067
1068 ascii_digest (out_buf1, 0, 0);
1069 ascii_digest (out_buf2, 0, 1);
1070
1071 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1072 }
1073 else
1074 {
1075 log_info ("Hash.Target....: File (%s)", data.hashfile);
1076 }
1077 }
1078
1079 log_info ("Hash.Type......: %s", hash_type);
1080
1081 /**
1082 * speed new
1083 */
1084
1085 uint64_t speed_cnt[DEVICES_MAX];
1086 float speed_ms[DEVICES_MAX];
1087
1088 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1089 {
1090 hc_device_param_t *device_param = &data.devices_param[device_id];
1091
1092 // we need to clear values (set to 0) because in case the device does
1093 // not get new candidates it idles around but speed display would
1094 // show it as working.
1095 // if we instantly set it to 0 after reading it happens that the
1096 // speed can be shown as zero if the users refreshs to fast.
1097 // therefore, we add a timestamp when a stat was recorded and if its
1098 // to old we will not use it
1099
1100 speed_cnt[device_id] = 0;
1101 speed_ms[device_id] = 0;
1102
1103 for (int i = 0; i < SPEED_CACHE; i++)
1104 {
1105 float rec_ms;
1106
1107 hc_timer_get (device_param->speed_rec[i], rec_ms);
1108
1109 if (rec_ms > SPEED_MAXAGE) continue;
1110
1111 speed_cnt[device_id] += device_param->speed_cnt[i];
1112 speed_ms[device_id] += device_param->speed_ms[i];
1113 }
1114
1115 speed_cnt[device_id] /= SPEED_CACHE;
1116 speed_ms[device_id] /= SPEED_CACHE;
1117 }
1118
1119 float hashes_all_ms = 0;
1120
1121 float hashes_dev_ms[DEVICES_MAX];
1122
1123 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1124 {
1125 hashes_dev_ms[device_id] = 0;
1126
1127 if (speed_ms[device_id])
1128 {
1129 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1130
1131 hashes_all_ms += hashes_dev_ms[device_id];
1132 }
1133 }
1134
1135 /**
1136 * timers
1137 */
1138
1139 float ms_running = 0;
1140
1141 hc_timer_get (data.timer_running, ms_running);
1142
1143 float ms_paused = data.ms_paused;
1144
1145 if (data.devices_status == STATUS_PAUSED)
1146 {
1147 float ms_paused_tmp = 0;
1148
1149 hc_timer_get (data.timer_paused, ms_paused_tmp);
1150
1151 ms_paused += ms_paused_tmp;
1152 }
1153
1154 #ifdef WIN
1155
1156 __time64_t sec_run = ms_running / 1000;
1157
1158 #else
1159
1160 time_t sec_run = ms_running / 1000;
1161
1162 #endif
1163
1164 if (sec_run)
1165 {
1166 char display_run[32];
1167
1168 struct tm tm_run;
1169
1170 struct tm *tmp;
1171
1172 #ifdef WIN
1173
1174 tmp = _gmtime64 (&sec_run);
1175
1176 #else
1177
1178 tmp = gmtime (&sec_run);
1179
1180 #endif
1181
1182 if (tmp != NULL)
1183 {
1184 memcpy (&tm_run, tmp, sizeof (struct tm));
1185
1186 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1187
1188 char *start = ctime (&data.proc_start);
1189
1190 size_t start_len = strlen (start);
1191
1192 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1193 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1194
1195 log_info ("Time.Started...: %s (%s)", start, display_run);
1196 }
1197 }
1198 else
1199 {
1200 log_info ("Time.Started...: 0 secs");
1201 }
1202
1203 /**
1204 * counters
1205 */
1206
1207 uint salts_left = data.salts_cnt - data.salts_done;
1208
1209 if (salts_left == 0) salts_left = 1;
1210
1211 uint64_t progress_total = data.words_cnt * salts_left;
1212
1213 uint64_t all_done = 0;
1214 uint64_t all_rejected = 0;
1215 uint64_t all_restored = 0;
1216
1217 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1218 {
1219 if (salts_left > 1)
1220 {
1221 // otherwise the final cracked status shows 0/XXX progress
1222
1223 if (data.salts_shown[salt_pos] == 1) continue;
1224 }
1225
1226 all_done += data.words_progress_done[salt_pos];
1227 all_rejected += data.words_progress_rejected[salt_pos];
1228 all_restored += data.words_progress_restored[salt_pos];
1229 }
1230
1231 uint64_t progress_cur = all_restored + all_done + all_rejected;
1232 uint64_t progress_end = progress_total;
1233
1234 uint64_t progress_skip = 0;
1235
1236 if (data.skip)
1237 {
1238 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1239
1240 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1241 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1242 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1243 }
1244
1245 if (data.limit)
1246 {
1247 progress_end = MIN (data.limit, data.words_base) * salts_left;
1248
1249 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1250 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1251 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1252 }
1253
1254 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
1255 uint64_t progress_end_relative_skip = progress_end - progress_skip;
1256
1257 float speed_ms_real = ms_running - ms_paused;
1258 uint64_t speed_plains_real = all_done;
1259
1260 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1261 {
1262 if (data.devices_status != STATUS_CRACKED)
1263 {
1264 uint64_t words_per_ms = 0;
1265
1266 if (speed_plains_real && speed_ms_real)
1267 {
1268 words_per_ms = speed_plains_real / speed_ms_real;
1269 }
1270
1271 #ifdef WIN
1272 __time64_t sec_etc = 0;
1273 #else
1274 time_t sec_etc = 0;
1275 #endif
1276
1277 if (words_per_ms)
1278 {
1279 uint64_t progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1280
1281 uint64_t ms_left = progress_left_relative_skip / words_per_ms;
1282
1283 sec_etc = ms_left / 1000;
1284 }
1285
1286 if (sec_etc == 0)
1287 {
1288 log_info ("Time.Estimated.: 0 secs");
1289 }
1290 else if ((uint64_t) sec_etc > ETC_MAX)
1291 {
1292 log_info ("Time.Estimated.: > 10 Years");
1293 }
1294 else
1295 {
1296 char display_etc[32];
1297
1298 struct tm tm_etc;
1299
1300 struct tm *tmp;
1301
1302 #ifdef WIN
1303
1304 tmp = _gmtime64 (&sec_etc);
1305
1306 #else
1307
1308 tmp = gmtime (&sec_etc);
1309
1310 #endif
1311
1312 if (tmp != NULL)
1313 {
1314 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1315
1316 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1317
1318 time_t now;
1319
1320 time (&now);
1321
1322 now += sec_etc;
1323
1324 char *etc = ctime (&now);
1325
1326 size_t etc_len = strlen (etc);
1327
1328 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1329 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1330
1331 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1332 }
1333 }
1334 }
1335 }
1336
1337 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1338 {
1339 char display_dev_cur[16];
1340
1341 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1342
1343 strncpy (display_dev_cur, "0.00", 4);
1344
1345 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1346
1347 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1348 }
1349
1350 char display_all_cur[16];
1351
1352 memset (display_all_cur, 0, sizeof (display_all_cur));
1353
1354 strncpy (display_all_cur, "0.00", 4);
1355
1356 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1357
1358 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1359
1360 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1361 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1362
1363 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1364
1365 // crack-per-time
1366
1367 if (data.digests_cnt > 100)
1368 {
1369 time_t now = time (NULL);
1370
1371 int cpt_cur_min = 0;
1372 int cpt_cur_hour = 0;
1373 int cpt_cur_day = 0;
1374
1375 for (int i = 0; i < CPT_BUF; i++)
1376 {
1377 const uint cracked = data.cpt_buf[i].cracked;
1378 const time_t timestamp = data.cpt_buf[i].timestamp;
1379
1380 if ((timestamp + 60) > now)
1381 {
1382 cpt_cur_min += cracked;
1383 }
1384
1385 if ((timestamp + 3600) > now)
1386 {
1387 cpt_cur_hour += cracked;
1388 }
1389
1390 if ((timestamp + 86400) > now)
1391 {
1392 cpt_cur_day += cracked;
1393 }
1394 }
1395
1396 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1397 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1398 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1399
1400 if ((data.cpt_start + 86400) < now)
1401 {
1402 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1403 cpt_cur_min,
1404 cpt_cur_hour,
1405 cpt_cur_day,
1406 cpt_avg_min,
1407 cpt_avg_hour,
1408 cpt_avg_day);
1409 }
1410 else if ((data.cpt_start + 3600) < now)
1411 {
1412 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1413 cpt_cur_min,
1414 cpt_cur_hour,
1415 cpt_avg_min,
1416 cpt_avg_hour,
1417 cpt_avg_day);
1418 }
1419 else if ((data.cpt_start + 60) < now)
1420 {
1421 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1422 cpt_cur_min,
1423 cpt_avg_min,
1424 cpt_avg_hour,
1425 cpt_avg_day);
1426 }
1427 else
1428 {
1429 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1430 cpt_avg_min,
1431 cpt_avg_hour,
1432 cpt_avg_day);
1433 }
1434 }
1435
1436 // Restore point
1437
1438 uint64_t restore_point = get_lowest_words_done ();
1439
1440 uint64_t restore_total = data.words_base;
1441
1442 float percent_restore = 0;
1443
1444 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1445
1446 if (progress_end_relative_skip)
1447 {
1448 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1449 {
1450 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1451 float percent_rejected = 0.0;
1452
1453 if (progress_cur)
1454 {
1455 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1456 }
1457
1458 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1459 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1460
1461 if (data.restore_disable == 0)
1462 {
1463 if (percent_finished != 1)
1464 {
1465 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1466 }
1467 }
1468 }
1469 }
1470 else
1471 {
1472 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1473 {
1474 log_info ("Progress.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1475 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1476
1477 if (data.restore_disable == 0)
1478 {
1479 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1480 }
1481 }
1482 else
1483 {
1484 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1485 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1486
1487 // --restore not allowed if stdin is used -- really? why?
1488
1489 //if (data.restore_disable == 0)
1490 //{
1491 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1492 //}
1493 }
1494 }
1495
1496 if (data.gpu_temp_disable == 0)
1497 {
1498 hc_thread_mutex_lock (mux_adl);
1499
1500 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1501 {
1502 hc_device_param_t *device_param = &data.devices_param[device_id];
1503
1504 #define HM_STR_BUF_SIZE 255
1505
1506 if (data.hm_device[device_id].fan_supported == 1)
1507 {
1508 char utilization[HM_STR_BUF_SIZE];
1509 char temperature[HM_STR_BUF_SIZE];
1510 char fanspeed[HM_STR_BUF_SIZE];
1511
1512 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1513 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1514
1515 if (device_param->vendor_id == VENDOR_ID_AMD)
1516 {
1517 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1518 }
1519 else if (device_param->vendor_id == VENDOR_ID_NV)
1520 {
1521 #ifdef LINUX
1522 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1523 #else
1524 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "rpm", hm_get_fanspeed_with_device_id (device_id));
1525 #endif
1526 }
1527
1528 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1529 }
1530 else
1531 {
1532 char utilization[HM_STR_BUF_SIZE];
1533 char temperature[HM_STR_BUF_SIZE];
1534
1535 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1536 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1537
1538 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1539 }
1540 }
1541
1542 hc_thread_mutex_unlock (mux_adl);
1543 }
1544 }
1545
1546 static void status_benchmark ()
1547 {
1548 if (data.devices_status == STATUS_INIT) return;
1549 if (data.devices_status == STATUS_STARTING) return;
1550
1551 if (data.words_cnt == 0) return;
1552
1553 uint64_t speed_cnt[DEVICES_MAX];
1554 float speed_ms[DEVICES_MAX];
1555
1556 uint device_id;
1557
1558 for (device_id = 0; device_id < data.devices_cnt; device_id++)
1559 {
1560 hc_device_param_t *device_param = &data.devices_param[device_id];
1561
1562 speed_cnt[device_id] = 0;
1563 speed_ms[device_id] = 0;
1564
1565 for (int i = 0; i < SPEED_CACHE; i++)
1566 {
1567 speed_cnt[device_id] += device_param->speed_cnt[i];
1568 speed_ms[device_id] += device_param->speed_ms[i];
1569 }
1570
1571 speed_cnt[device_id] /= SPEED_CACHE;
1572 speed_ms[device_id] /= SPEED_CACHE;
1573 }
1574
1575 float hashes_all_ms = 0;
1576
1577 float hashes_dev_ms[DEVICES_MAX];
1578
1579 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1580 {
1581 hashes_dev_ms[device_id] = 0;
1582
1583 if (speed_ms[device_id])
1584 {
1585 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1586
1587 hashes_all_ms += hashes_dev_ms[device_id];
1588 }
1589 }
1590
1591 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1592 {
1593 char display_dev_cur[16];
1594
1595 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1596
1597 strncpy (display_dev_cur, "0.00", 4);
1598
1599 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1600
1601 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1602 }
1603
1604 char display_all_cur[16];
1605
1606 memset (display_all_cur, 0, sizeof (display_all_cur));
1607
1608 strncpy (display_all_cur, "0.00", 4);
1609
1610 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1611
1612 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1613 }
1614
1615 /**
1616 * oclHashcat -only- functions
1617 */
1618
1619 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1620 {
1621 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1622 {
1623 if (attack_kern == ATTACK_KERN_STRAIGHT)
1624 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1625 else if (attack_kern == ATTACK_KERN_COMBI)
1626 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1627 else if (attack_kern == ATTACK_KERN_BF)
1628 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1629 }
1630 else
1631 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1632 }
1633
1634 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1635 {
1636 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1637 {
1638 if (attack_kern == ATTACK_KERN_STRAIGHT)
1639 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1640 else if (attack_kern == ATTACK_KERN_COMBI)
1641 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1642 else if (attack_kern == ATTACK_KERN_BF)
1643 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1644 }
1645 else
1646 {
1647 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1648 }
1649 }
1650
1651 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1652 {
1653 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1654 {
1655 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1656 }
1657 else
1658 {
1659 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1660 }
1661 }
1662
1663 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1664 {
1665 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1666 {
1667 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1668 }
1669 else
1670 {
1671 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1672 }
1673 }
1674
1675 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1676 {
1677 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1678 }
1679
1680 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1681 {
1682 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1683 }
1684
1685 static uint convert_from_hex (char *line_buf, const uint line_len)
1686 {
1687 if (line_len & 1) return (line_len); // not in hex
1688
1689 if (data.hex_wordlist == 1)
1690 {
1691 uint i;
1692 uint j;
1693
1694 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1695 {
1696 line_buf[i] = hex_to_char (&line_buf[j]);
1697 }
1698
1699 memset (line_buf + i, 0, line_len - i);
1700
1701 return (i);
1702 }
1703 else if (line_len >= 6) // $HEX[] = 6
1704 {
1705 if (line_buf[0] != '$') return (line_len);
1706 if (line_buf[1] != 'H') return (line_len);
1707 if (line_buf[2] != 'E') return (line_len);
1708 if (line_buf[3] != 'X') return (line_len);
1709 if (line_buf[4] != '[') return (line_len);
1710 if (line_buf[line_len - 1] != ']') return (line_len);
1711
1712 uint i;
1713 uint j;
1714
1715 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1716 {
1717 line_buf[i] = hex_to_char (&line_buf[j]);
1718 }
1719
1720 memset (line_buf + i, 0, line_len - i);
1721
1722 return (i);
1723 }
1724
1725 return (line_len);
1726 }
1727
1728 static uint count_lines (FILE *fd)
1729 {
1730 uint cnt = 0;
1731
1732 char *buf = (char *) mymalloc (BUFSIZ);
1733
1734 size_t nread_tmp = 0;
1735
1736 char *ptr = buf;
1737
1738 while (!feof (fd))
1739 {
1740 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1741 nread_tmp = nread;
1742
1743 if (nread < 1) continue;
1744
1745 ptr = buf;
1746
1747 do
1748 {
1749 if (*ptr++ == '\n') cnt++;
1750
1751 } while (nread--);
1752 }
1753
1754 // special case (if last line did not contain a newline char ... at the very end of the file)
1755
1756 if (nread_tmp > 3)
1757 {
1758 ptr -= 2;
1759
1760 if (*ptr != '\n')
1761 {
1762 ptr--;
1763
1764 if (*ptr != '\n') // needed ? different on windows systems?
1765 {
1766 cnt++;
1767 }
1768 }
1769 }
1770
1771 myfree (buf);
1772
1773 return cnt;
1774 }
1775
1776 static void clear_prompt ()
1777 {
1778 fputc ('\r', stdout);
1779
1780 for (size_t i = 0; i < strlen (PROMPT); i++)
1781 {
1782 fputc (' ', stdout);
1783 }
1784
1785 fputc ('\r', stdout);
1786
1787 fflush (stdout);
1788 }
1789
1790 static void gidd_to_pw_t (hc_device_param_t *device_param, const uint64_t gidd, pw_t *pw)
1791 {
1792 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1793 }
1794
1795 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1796 {
1797 char *outfile = data.outfile;
1798 uint quiet = data.quiet;
1799 FILE *pot_fp = data.pot_fp;
1800 uint loopback = data.loopback;
1801 uint debug_mode = data.debug_mode;
1802 char *debug_file = data.debug_file;
1803
1804 char debug_rule_buf[BLOCK_SIZE];
1805 int debug_rule_len = 0; // -1 error
1806 uint debug_plain_len = 0;
1807
1808 unsigned char debug_plain_ptr[BLOCK_SIZE];
1809
1810 // hash
1811
1812 char out_buf[4096]; memset (out_buf, 0, sizeof (out_buf));
1813
1814 ascii_digest (out_buf, salt_pos, digest_pos);
1815
1816 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1817
1818 // plain
1819
1820 plain_t plain;
1821
1822 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1823
1824 uint gidvid = plain.gidvid;
1825 uint il_pos = plain.il_pos;
1826
1827 uint64_t crackpos = device_param->words_off;
1828
1829 uint plain_buf[16];
1830
1831 unsigned char *plain_ptr = (unsigned char *) plain_buf;
1832 unsigned int plain_len = 0;
1833
1834 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1835 {
1836 uint64_t gidd = gidvid;
1837 uint64_t gidm = 0;
1838
1839 pw_t pw;
1840
1841 gidd_to_pw_t (device_param, gidd, &pw);
1842
1843 for (int i = 0, j = gidm; i < 16; i++, j++)
1844 {
1845 plain_buf[i] = pw.hi1[0][j];
1846 }
1847
1848 plain_len = pw.pw_len;
1849
1850 const uint off = device_param->innerloop_pos + il_pos;
1851
1852 if (debug_mode > 0)
1853 {
1854 debug_rule_len = 0;
1855
1856 // save rule
1857 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1858 {
1859 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1860
1861 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1862 }
1863
1864 // save plain
1865 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1866 {
1867 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1868
1869 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1870
1871 debug_plain_len = plain_len;
1872 }
1873 }
1874
1875 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1876
1877 crackpos += gidvid;
1878 crackpos *= data.kernel_rules_cnt;
1879 crackpos += device_param->innerloop_pos + il_pos;
1880
1881 if (plain_len > data.pw_max) plain_len = data.pw_max;
1882 }
1883 else if (data.attack_mode == ATTACK_MODE_COMBI)
1884 {
1885 uint64_t gidd = gidvid;
1886 uint64_t gidm = 0;
1887
1888 pw_t pw;
1889
1890 gidd_to_pw_t (device_param, gidd, &pw);
1891
1892 for (int i = 0, j = gidm; i < 16; i++, j++)
1893 {
1894 plain_buf[i] = pw.hi1[0][j];
1895 }
1896
1897 plain_len = pw.pw_len;
1898
1899 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1900 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1901
1902 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1903 {
1904 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1905 }
1906 else
1907 {
1908 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1909
1910 memcpy (plain_ptr, comb_buf, comb_len);
1911 }
1912
1913 plain_len += comb_len;
1914
1915 crackpos += gidvid;
1916 crackpos *= data.combs_cnt;
1917 crackpos += device_param->innerloop_pos + il_pos;
1918
1919 if (data.pw_max != PW_DICTMAX1)
1920 {
1921 if (plain_len > data.pw_max) plain_len = data.pw_max;
1922 }
1923 }
1924 else if (data.attack_mode == ATTACK_MODE_BF)
1925 {
1926 uint64_t l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1927 uint64_t r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1928
1929 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1930 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1931
1932 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1933 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1934
1935 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1936 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1937
1938 plain_len = data.css_cnt;
1939
1940 crackpos += gidvid;
1941 crackpos *= data.bfs_cnt;
1942 crackpos += device_param->innerloop_pos + il_pos;
1943 }
1944 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1945 {
1946 uint64_t gidd = gidvid;
1947 uint64_t gidm = 0;
1948
1949 pw_t pw;
1950
1951 gidd_to_pw_t (device_param, gidd, &pw);
1952
1953 for (int i = 0, j = gidm; i < 16; i++, j++)
1954 {
1955 plain_buf[i] = pw.hi1[0][j];
1956 }
1957
1958 plain_len = pw.pw_len;
1959
1960 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1961
1962 uint start = 0;
1963 uint stop = device_param->kernel_params_mp_buf32[4];
1964
1965 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1966
1967 plain_len += start + stop;
1968
1969 crackpos += gidvid;
1970 crackpos *= data.combs_cnt;
1971 crackpos += device_param->innerloop_pos + il_pos;
1972
1973 if (data.pw_max != PW_DICTMAX1)
1974 {
1975 if (plain_len > data.pw_max) plain_len = data.pw_max;
1976 }
1977 }
1978 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1979 {
1980 uint64_t gidd = gidvid;
1981 uint64_t gidm = 0;
1982
1983 pw_t pw;
1984
1985 gidd_to_pw_t (device_param, gidd, &pw);
1986
1987 for (int i = 0, j = gidm; i < 16; i++, j++)
1988 {
1989 plain_buf[i] = pw.hi1[0][j];
1990 }
1991
1992 plain_len = pw.pw_len;
1993
1994 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1995
1996 uint start = 0;
1997 uint stop = device_param->kernel_params_mp_buf32[4];
1998
1999 memmove (plain_ptr + stop, plain_ptr, plain_len);
2000
2001 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2002
2003 plain_len += start + stop;
2004
2005 crackpos += gidvid;
2006 crackpos *= data.combs_cnt;
2007 crackpos += device_param->innerloop_pos + il_pos;
2008
2009 if (data.pw_max != PW_DICTMAX1)
2010 {
2011 if (plain_len > data.pw_max) plain_len = data.pw_max;
2012 }
2013 }
2014
2015 if (data.attack_mode == ATTACK_MODE_BF)
2016 {
2017 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2018 {
2019 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2020 {
2021 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2022 {
2023 plain_len = plain_len - data.salts_buf[0].salt_len;
2024 }
2025 }
2026
2027 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2028 {
2029 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2030 {
2031 plain_ptr[j] = plain_ptr[i];
2032 }
2033
2034 plain_len = plain_len / 2;
2035 }
2036 }
2037 }
2038
2039 // if enabled, update also the potfile
2040
2041 if (pot_fp)
2042 {
2043 fprintf (pot_fp, "%s:", out_buf);
2044
2045 format_plain (pot_fp, plain_ptr, plain_len, 1);
2046
2047 fputc ('\n', pot_fp);
2048
2049 fflush (pot_fp);
2050 }
2051
2052 // outfile
2053
2054 FILE *out_fp = NULL;
2055
2056 if (outfile != NULL)
2057 {
2058 if ((out_fp = fopen (outfile, "ab")) == NULL)
2059 {
2060 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2061
2062 out_fp = stdout;
2063 }
2064 }
2065 else
2066 {
2067 out_fp = stdout;
2068
2069 if (quiet == 0) clear_prompt ();
2070 }
2071
2072 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2073
2074 if (outfile != NULL)
2075 {
2076 if (out_fp != stdout)
2077 {
2078 fclose (out_fp);
2079 }
2080 }
2081 else
2082 {
2083 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2084 {
2085 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2086 {
2087 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2088 if (quiet == 0) fflush (stdout);
2089 }
2090 }
2091 }
2092
2093 // loopback
2094
2095 if (loopback)
2096 {
2097 char *loopback_file = data.loopback_file;
2098
2099 FILE *fb_fp = NULL;
2100
2101 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2102 {
2103 format_plain (fb_fp, plain_ptr, plain_len, 1);
2104
2105 fputc ('\n', fb_fp);
2106
2107 fclose (fb_fp);
2108 }
2109 }
2110
2111 // (rule) debug mode
2112
2113 // the next check implies that:
2114 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2115 // - debug_mode > 0
2116
2117 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2118 {
2119 if (debug_rule_len < 0) debug_rule_len = 0;
2120
2121 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2122
2123 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2124
2125 if ((quiet == 0) && (debug_file == NULL))
2126 {
2127 fprintf (stdout, "%s", PROMPT);
2128 fflush (stdout);
2129 }
2130 }
2131 }
2132
2133 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2134 {
2135 salt_t *salt_buf = &data.salts_buf[salt_pos];
2136
2137 int found = 0;
2138
2139 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2140
2141 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2142
2143 if (found == 1)
2144 {
2145 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2146
2147 log_info_nn ("");
2148
2149 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2150
2151 uint cpt_cracked = 0;
2152
2153 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2154 {
2155 uint idx = salt_buf->digests_offset + digest_pos;
2156
2157 if (data.digests_shown_tmp[idx] == 0) continue;
2158
2159 if (data.digests_shown[idx] == 1) continue;
2160
2161 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2162 {
2163 data.digests_shown[idx] = 1;
2164
2165 data.digests_done++;
2166
2167 cpt_cracked++;
2168
2169 salt_buf->digests_done++;
2170
2171 if (salt_buf->digests_done == salt_buf->digests_cnt)
2172 {
2173 data.salts_shown[salt_pos] = 1;
2174
2175 data.salts_done++;
2176 }
2177 }
2178
2179 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2180
2181 check_hash (device_param, salt_pos, digest_pos);
2182 }
2183
2184 if (cpt_cracked > 0)
2185 {
2186 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2187 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2188
2189 data.cpt_pos++;
2190
2191 data.cpt_total += cpt_cracked;
2192
2193 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2194 }
2195
2196 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2197 {
2198 // we need to reset cracked state on the device
2199 // otherwise host thinks again and again the hash was cracked
2200 // and returns invalid password each time
2201
2202 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2203
2204 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2205 }
2206
2207 memset (device_param->result, 0, device_param->size_results);
2208
2209 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2210 }
2211 }
2212
2213 static void save_hash ()
2214 {
2215 char *hashfile = data.hashfile;
2216
2217 char new_hashfile[256];
2218 char old_hashfile[256];
2219
2220 memset (new_hashfile, 0, sizeof (new_hashfile));
2221 memset (old_hashfile, 0, sizeof (old_hashfile));
2222
2223 snprintf (new_hashfile, 255, "%s.new", hashfile);
2224 snprintf (old_hashfile, 255, "%s.old", hashfile);
2225
2226 unlink (new_hashfile);
2227
2228 char separator = data.separator;
2229
2230 FILE *fp = fopen (new_hashfile, "wb");
2231
2232 if (fp == NULL)
2233 {
2234 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2235
2236 exit (-1);
2237 }
2238
2239 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2240 {
2241 if (data.salts_shown[salt_pos] == 1) continue;
2242
2243 salt_t *salt_buf = &data.salts_buf[salt_pos];
2244
2245 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2246 {
2247 uint idx = salt_buf->digests_offset + digest_pos;
2248
2249 if (data.digests_shown[idx] == 1) continue;
2250
2251 if (data.hash_mode != 2500)
2252 {
2253 char out_buf[4096];
2254
2255 memset (out_buf, 0, sizeof (out_buf));
2256
2257 if (data.username == 1)
2258 {
2259 user_t *user = data.hash_info[idx]->user;
2260
2261 uint i;
2262
2263 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2264
2265 fputc (separator, fp);
2266 }
2267
2268 ascii_digest (out_buf, salt_pos, digest_pos);
2269
2270 fputs (out_buf, fp);
2271
2272 log_out (fp, "");
2273 }
2274 else
2275 {
2276 hccap_t hccap;
2277
2278 to_hccap_t (&hccap, salt_pos, digest_pos);
2279
2280 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2281 }
2282 }
2283 }
2284
2285 fflush (fp);
2286
2287 fclose (fp);
2288
2289 unlink (old_hashfile);
2290
2291 if (rename (hashfile, old_hashfile) != 0)
2292 {
2293 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2294
2295 exit (-1);
2296 }
2297
2298 unlink (hashfile);
2299
2300 if (rename (new_hashfile, hashfile) != 0)
2301 {
2302 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2303
2304 exit (-1);
2305 }
2306
2307 unlink (old_hashfile);
2308 }
2309
2310 static float find_kernel_blocks_div (const uint64_t total_left, const uint kernel_blocks_all)
2311 {
2312 // function called only in case kernel_blocks_all > words_left)
2313
2314 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2315
2316 kernel_blocks_div += kernel_blocks_div / 100;
2317
2318 uint32_t kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2319
2320 while (kernel_blocks_new < total_left)
2321 {
2322 kernel_blocks_div += kernel_blocks_div / 100;
2323
2324 kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2325 }
2326
2327 if (data.quiet == 0)
2328 {
2329 clear_prompt ();
2330
2331 log_info ("");
2332
2333 log_info ("INFO: approaching final keyspace, workload adjusted");
2334
2335 log_info ("");
2336
2337 fprintf (stdout, "%s", PROMPT);
2338
2339 fflush (stdout);
2340 }
2341
2342 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2343
2344 return kernel_blocks_div;
2345 }
2346
2347 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2348 {
2349 uint num_elements = num;
2350
2351 device_param->kernel_params_buf32[30] = data.combs_mode;
2352 device_param->kernel_params_buf32[31] = num;
2353
2354 uint kernel_threads = device_param->kernel_threads;
2355
2356 while (num_elements % kernel_threads) num_elements++;
2357
2358 cl_kernel kernel = NULL;
2359
2360 switch (kern_run)
2361 {
2362 case KERN_RUN_1: kernel = device_param->kernel1; break;
2363 case KERN_RUN_12: kernel = device_param->kernel12; break;
2364 case KERN_RUN_2: kernel = device_param->kernel2; break;
2365 case KERN_RUN_23: kernel = device_param->kernel23; break;
2366 case KERN_RUN_3: kernel = device_param->kernel3; break;
2367 }
2368
2369 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2370 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2371 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2372 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2373 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2374 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2375 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2376 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2377 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2378 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2379 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2380
2381 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2382 {
2383 const size_t global_work_size[3] = { num_elements, 32, 1 };
2384 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2385
2386 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2387 }
2388 else
2389 {
2390 const size_t global_work_size[3] = { num_elements, 1, 1 };
2391 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2392
2393 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2394 }
2395
2396 hc_clFlush (device_param->command_queue);
2397
2398 hc_clFinish (device_param->command_queue);
2399 }
2400
2401 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2402 {
2403 uint num_elements = num;
2404
2405 switch (kern_run)
2406 {
2407 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2408 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2409 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2410 }
2411
2412 // causes problems with special threads like in bcrypt
2413 // const uint kernel_threads = device_param->kernel_threads;
2414
2415 const uint kernel_threads = KERNEL_THREADS;
2416
2417 while (num_elements % kernel_threads) num_elements++;
2418
2419 cl_kernel kernel = NULL;
2420
2421 switch (kern_run)
2422 {
2423 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2424 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2425 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2426 }
2427
2428 switch (kern_run)
2429 {
2430 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2431 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2432 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2433 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2434 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2435 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2436 break;
2437 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2438 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2439 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2440 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2441 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2442 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2443 break;
2444 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2445 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2446 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2447 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2448 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2449 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2450 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2451 break;
2452 }
2453
2454 const size_t global_work_size[3] = { num_elements, 1, 1 };
2455 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2456
2457 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2458
2459 hc_clFlush (device_param->command_queue);
2460
2461 hc_clFinish (device_param->command_queue);
2462 }
2463
2464 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2465 {
2466 uint num_elements = num;
2467
2468 uint kernel_threads = device_param->kernel_threads;
2469
2470 while (num_elements % kernel_threads) num_elements++;
2471
2472 cl_kernel kernel = device_param->kernel_tb;
2473
2474 const size_t global_work_size[3] = { num_elements, 1, 1 };
2475 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2476
2477 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2478
2479 hc_clFlush (device_param->command_queue);
2480
2481 hc_clFinish (device_param->command_queue);
2482 }
2483
2484 static void run_kernel_tm (hc_device_param_t *device_param)
2485 {
2486 const uint num_elements = 1024; // fixed
2487
2488 const uint kernel_threads = 32;
2489
2490 cl_kernel kernel = device_param->kernel_tm;
2491
2492 const size_t global_work_size[3] = { num_elements, 1, 1 };
2493 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2494
2495 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2496
2497 hc_clFlush (device_param->command_queue);
2498
2499 hc_clFinish (device_param->command_queue);
2500 }
2501
2502 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2503 {
2504 uint num_elements = num;
2505
2506 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2507 device_param->kernel_params_amp_buf32[6] = num_elements;
2508
2509 // causes problems with special threads like in bcrypt
2510 // const uint kernel_threads = device_param->kernel_threads;
2511
2512 const uint kernel_threads = KERNEL_THREADS;
2513
2514 while (num_elements % kernel_threads) num_elements++;
2515
2516 cl_kernel kernel = device_param->kernel_amp;
2517
2518 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2519 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2520
2521 const size_t global_work_size[3] = { num_elements, 1, 1 };
2522 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2523
2524 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2525
2526 hc_clFlush (device_param->command_queue);
2527
2528 hc_clFinish (device_param->command_queue);
2529 }
2530
2531 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2532 {
2533 if (device_param->vendor_id == VENDOR_ID_AMD)
2534 {
2535 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2536
2537 const cl_uchar zero = 0;
2538
2539 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2540 }
2541 else
2542 {
2543 // NOTE: clEnqueueFillBuffer () always fails with -59
2544 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults
2545 // How's that possible, OpenCL 1.2 support is advertised??
2546 // We need to workaround...
2547
2548 #define FILLSZ 0x100000
2549
2550 char *tmp = (char *) mymalloc (FILLSZ);
2551
2552 memset (tmp, 0, FILLSZ);
2553
2554 for (uint i = 0; i < size; i += FILLSZ)
2555 {
2556 const int left = size - i;
2557
2558 const int fillsz = MIN (FILLSZ, left);
2559
2560 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2561 }
2562
2563 myfree (tmp);
2564 }
2565 }
2566
2567 static int run_rule_engine (const int rule_len, const char *rule_buf)
2568 {
2569 if (rule_len == 0)
2570 {
2571 return 0;
2572 }
2573 else if (rule_len == 1)
2574 {
2575 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2576 }
2577
2578 return 1;
2579 }
2580
2581 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2582 {
2583 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2584 {
2585 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2586 }
2587 else if (data.attack_kern == ATTACK_KERN_COMBI)
2588 {
2589 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2590 }
2591 else if (data.attack_kern == ATTACK_KERN_BF)
2592 {
2593 const uint64_t off = device_param->words_off;
2594
2595 device_param->kernel_params_mp_l_buf64[3] = off;
2596
2597 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2598 }
2599 }
2600
2601 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2602 {
2603 const uint kernel_loops = data.kernel_loops;
2604
2605 // init speed timer
2606
2607 uint speed_pos = device_param->speed_pos;
2608
2609 #ifdef _POSIX
2610 if (device_param->timer_speed.tv_sec == 0)
2611 {
2612 hc_timer_set (&device_param->timer_speed);
2613 }
2614 #endif
2615
2616 #ifdef _WIN
2617 if (device_param->timer_speed.QuadPart == 0)
2618 {
2619 hc_timer_set (&device_param->timer_speed);
2620 }
2621 #endif
2622
2623 // find higest password length, this is for optimization stuff
2624
2625 uint highest_pw_len = 0;
2626
2627 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2628 {
2629 }
2630 else if (data.attack_kern == ATTACK_KERN_COMBI)
2631 {
2632 }
2633 else if (data.attack_kern == ATTACK_KERN_BF)
2634 {
2635 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2636 + device_param->kernel_params_mp_l_buf32[5];
2637 }
2638
2639 // bitslice optimization stuff
2640
2641 if (data.attack_mode == ATTACK_MODE_BF)
2642 {
2643 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2644 {
2645 run_kernel_tb (device_param, pws_cnt);
2646 }
2647 }
2648
2649 // iteration type
2650
2651 uint innerloop_step = 0;
2652 uint innerloop_cnt = 0;
2653
2654 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2655 else innerloop_step = 1;
2656
2657 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2658 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2659 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2660
2661 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2662
2663 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2664 {
2665 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2666
2667 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2668
2669 if (data.devices_status == STATUS_CRACKED) break;
2670 if (data.devices_status == STATUS_ABORTED) break;
2671 if (data.devices_status == STATUS_QUIT) break;
2672 if (data.devices_status == STATUS_BYPASS) break;
2673
2674 if (data.salts_shown[salt_pos] == 1) continue;
2675
2676 salt_t *salt_buf = &data.salts_buf[salt_pos];
2677
2678 device_param->kernel_params_buf32[24] = salt_pos;
2679 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2680 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2681
2682 FILE *combs_fp = device_param->combs_fp;
2683
2684 if (data.attack_mode == ATTACK_MODE_COMBI)
2685 {
2686 rewind (combs_fp);
2687 }
2688
2689 // innerloops
2690
2691 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2692 {
2693 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2694
2695 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2696
2697 if (data.devices_status == STATUS_CRACKED) break;
2698 if (data.devices_status == STATUS_ABORTED) break;
2699 if (data.devices_status == STATUS_QUIT) break;
2700 if (data.devices_status == STATUS_BYPASS) break;
2701
2702 uint innerloop_left = innerloop_cnt - innerloop_pos;
2703
2704 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2705
2706 device_param->innerloop_pos = innerloop_pos;
2707 device_param->innerloop_left = innerloop_left;
2708
2709 device_param->kernel_params_buf32[27] = innerloop_left;
2710
2711 if (innerloop_left == 0) continue;
2712
2713 // initialize amplifiers
2714
2715 if (data.attack_mode == ATTACK_MODE_COMBI)
2716 {
2717 char line_buf[BUFSIZ];
2718
2719 uint i = 0;
2720
2721 while (i < innerloop_left)
2722 {
2723 if (feof (combs_fp)) break;
2724
2725 int line_len = fgetl (combs_fp, line_buf);
2726
2727 if (line_len >= PW_MAX1) continue;
2728
2729 line_len = convert_from_hex (line_buf, line_len);
2730
2731 char *line_buf_new = line_buf;
2732
2733 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2734 {
2735 char rule_buf_out[BLOCK_SIZE];
2736
2737 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2738
2739 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2740
2741 if (rule_len_out < 0)
2742 {
2743 data.words_progress_rejected[salt_pos] += pw_cnt;
2744
2745 continue;
2746 }
2747
2748 line_len = rule_len_out;
2749
2750 line_buf_new = rule_buf_out;
2751 }
2752
2753 line_len = MIN (line_len, PW_DICTMAX);
2754
2755 char *ptr = (char *) device_param->combs_buf[i].i;
2756
2757 memcpy (ptr, line_buf_new, line_len);
2758
2759 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2760
2761 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2762 {
2763 uppercase (ptr, line_len);
2764 }
2765
2766 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2767 {
2768 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2769 {
2770 ptr[line_len] = 0x80;
2771 }
2772
2773 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2774 {
2775 ptr[line_len] = 0x01;
2776 }
2777 }
2778
2779 device_param->combs_buf[i].pw_len = line_len;
2780
2781 i++;
2782 }
2783
2784 for (uint j = i; j < innerloop_left; j++)
2785 {
2786 device_param->combs_buf[j].i[0] = 0;
2787 device_param->combs_buf[j].i[1] = 0;
2788 device_param->combs_buf[j].i[2] = 0;
2789 device_param->combs_buf[j].i[3] = 0;
2790 device_param->combs_buf[j].i[4] = 0;
2791 device_param->combs_buf[j].i[5] = 0;
2792 device_param->combs_buf[j].i[6] = 0;
2793 device_param->combs_buf[j].i[7] = 0;
2794
2795 device_param->combs_buf[j].pw_len = 0;
2796 }
2797
2798 innerloop_left = i;
2799 }
2800 else if (data.attack_mode == ATTACK_MODE_BF)
2801 {
2802 uint64_t off = innerloop_pos;
2803
2804 device_param->kernel_params_mp_r_buf64[3] = off;
2805
2806 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2807 }
2808 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2809 {
2810 uint64_t off = innerloop_pos;
2811
2812 device_param->kernel_params_mp_buf64[3] = off;
2813
2814 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2815 }
2816 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2817 {
2818 uint64_t off = innerloop_pos;
2819
2820 device_param->kernel_params_mp_buf64[3] = off;
2821
2822 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2823 }
2824
2825 // copy amplifiers
2826
2827 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2828 {
2829 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
2830 }
2831 else if (data.attack_mode == ATTACK_MODE_COMBI)
2832 {
2833 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
2834 }
2835 else if (data.attack_mode == ATTACK_MODE_BF)
2836 {
2837 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
2838 }
2839 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2840 {
2841 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2842 }
2843 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2844 {
2845 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2846 }
2847
2848 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2849 {
2850 if (data.attack_mode == ATTACK_MODE_BF)
2851 {
2852 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2853 {
2854 const uint size_tm = 32 * sizeof (bs_word_t);
2855
2856 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2857
2858 run_kernel_tm (device_param);
2859
2860 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2861 }
2862 }
2863
2864 if (highest_pw_len < 16)
2865 {
2866 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2867 }
2868 else if (highest_pw_len < 32)
2869 {
2870 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2871 }
2872 else
2873 {
2874 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2875 }
2876 }
2877 else
2878 {
2879 run_kernel_amp (device_param, pws_cnt);
2880
2881 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2882
2883 if (data.opts_type & OPTS_TYPE_HOOK12)
2884 {
2885 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2886 }
2887
2888 uint iter = salt_buf->salt_iter;
2889
2890 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2891 {
2892 uint loop_left = iter - loop_pos;
2893
2894 loop_left = MIN (loop_left, kernel_loops);
2895
2896 device_param->kernel_params_buf32[25] = loop_pos;
2897 device_param->kernel_params_buf32[26] = loop_left;
2898
2899 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2900
2901 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2902
2903 if (data.devices_status == STATUS_CRACKED) break;
2904 if (data.devices_status == STATUS_ABORTED) break;
2905 if (data.devices_status == STATUS_QUIT) break;
2906 }
2907
2908 if (data.opts_type & OPTS_TYPE_HOOK23)
2909 {
2910 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2911
2912 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2913
2914 // do something with data
2915
2916 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2917 }
2918
2919 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2920 }
2921
2922 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2923
2924 if (data.devices_status == STATUS_CRACKED) break;
2925 if (data.devices_status == STATUS_ABORTED) break;
2926 if (data.devices_status == STATUS_QUIT) break;
2927
2928 /**
2929 * result
2930 */
2931
2932 hc_thread_mutex_lock (mux_display);
2933
2934 check_cracked (device_param, salt_pos);
2935
2936 hc_thread_mutex_unlock (mux_display);
2937
2938 /**
2939 * progress
2940 */
2941
2942 uint64_t perf_sum_all = (uint64_t) pw_cnt * (uint64_t) innerloop_left;
2943
2944 hc_thread_mutex_lock (mux_counter);
2945
2946 data.words_progress_done[salt_pos] += perf_sum_all;
2947
2948 hc_thread_mutex_unlock (mux_counter);
2949
2950 /**
2951 * speed
2952 */
2953
2954 float speed_ms;
2955
2956 hc_timer_get (device_param->timer_speed, speed_ms);
2957
2958 hc_timer_set (&device_param->timer_speed);
2959
2960 hc_thread_mutex_lock (mux_display);
2961
2962 device_param->speed_cnt[speed_pos] = perf_sum_all;
2963
2964 device_param->speed_ms[speed_pos] = speed_ms;
2965
2966 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2967
2968 hc_thread_mutex_unlock (mux_display);
2969
2970 speed_pos++;
2971
2972 if (speed_pos == SPEED_CACHE)
2973 {
2974 speed_pos = 0;
2975 }
2976 }
2977 }
2978
2979 device_param->speed_pos = speed_pos;
2980 }
2981
2982 static void load_segment (wl_data_t *wl_data, FILE *fd)
2983 {
2984 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2985
2986 wl_data->pos = 0;
2987
2988 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
2989
2990 wl_data->buf[wl_data->cnt] = 0;
2991
2992 if (wl_data->cnt == 0) return;
2993
2994 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
2995
2996 while (!feof (fd))
2997 {
2998 if (wl_data->cnt == wl_data->avail)
2999 {
3000 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3001
3002 wl_data->avail += wl_data->incr;
3003 }
3004
3005 const int c = fgetc (fd);
3006
3007 if (c == EOF) break;
3008
3009 wl_data->buf[wl_data->cnt] = (char) c;
3010
3011 wl_data->cnt++;
3012
3013 if (c == '\n') break;
3014 }
3015
3016 // ensure stream ends with a newline
3017
3018 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3019 {
3020 wl_data->cnt++;
3021
3022 wl_data->buf[wl_data->cnt - 1] = '\n';
3023 }
3024
3025 return;
3026 }
3027
3028 static void get_next_word_lm (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3029 {
3030 char *ptr = buf;
3031
3032 for (uint32_t i = 0; i < sz; i++, ptr++)
3033 {
3034 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3035
3036 if (i == 7)
3037 {
3038 *off = i;
3039 *len = i;
3040
3041 return;
3042 }
3043
3044 if (*ptr != '\n') continue;
3045
3046 *off = i + 1;
3047
3048 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3049
3050 *len = i;
3051
3052 return;
3053 }
3054
3055 *off = sz;
3056 *len = sz;
3057 }
3058
3059 static void get_next_word_uc (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3060 {
3061 char *ptr = buf;
3062
3063 for (uint32_t i = 0; i < sz; i++, ptr++)
3064 {
3065 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3066
3067 if (*ptr != '\n') continue;
3068
3069 *off = i + 1;
3070
3071 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3072
3073 *len = i;
3074
3075 return;
3076 }
3077
3078 *off = sz;
3079 *len = sz;
3080 }
3081
3082 static void get_next_word_std (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3083 {
3084 char *ptr = buf;
3085
3086 for (uint32_t i = 0; i < sz; i++, ptr++)
3087 {
3088 if (*ptr != '\n') continue;
3089
3090 *off = i + 1;
3091
3092 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3093
3094 *len = i;
3095
3096 return;
3097 }
3098
3099 *off = sz;
3100 *len = sz;
3101 }
3102
3103 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3104 {
3105 while (wl_data->pos < wl_data->cnt)
3106 {
3107 uint off;
3108 uint len;
3109
3110 char *ptr = wl_data->buf + wl_data->pos;
3111
3112 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3113
3114 wl_data->pos += off;
3115
3116 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3117 {
3118 char rule_buf_out[BLOCK_SIZE];
3119
3120 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3121
3122 int rule_len_out = -1;
3123
3124 if (len < BLOCK_SIZE)
3125 {
3126 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3127 }
3128
3129 if (rule_len_out < 0)
3130 {
3131 continue;
3132 }
3133
3134 if (rule_len_out > PW_MAX)
3135 {
3136 continue;
3137 }
3138 }
3139 else
3140 {
3141 if (len > PW_MAX)
3142 {
3143 continue;
3144 }
3145 }
3146
3147 *out_buf = ptr;
3148 *out_len = len;
3149
3150 return;
3151 }
3152
3153 if (feof (fd))
3154 {
3155 fprintf (stderr, "bug!!\n");
3156
3157 return;
3158 }
3159
3160 load_segment (wl_data, fd);
3161
3162 get_next_word (wl_data, fd, out_buf, out_len);
3163 }
3164
3165 #ifdef _POSIX
3166 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3167 #endif
3168
3169 #ifdef _WIN
3170 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3171 #endif
3172 {
3173 hc_signal (NULL);
3174
3175 dictstat_t d;
3176
3177 d.cnt = 0;
3178
3179 #ifdef _POSIX
3180 fstat (fileno (fd), &d.stat);
3181 #endif
3182
3183 #ifdef _WIN
3184 _fstat64 (fileno (fd), &d.stat);
3185 #endif
3186
3187 d.stat.st_mode = 0;
3188 d.stat.st_nlink = 0;
3189 d.stat.st_uid = 0;
3190 d.stat.st_gid = 0;
3191 d.stat.st_rdev = 0;
3192 d.stat.st_atime = 0;
3193
3194 #ifdef _POSIX
3195 d.stat.st_blksize = 0;
3196 d.stat.st_blocks = 0;
3197 #endif
3198
3199 if (d.stat.st_size == 0) return 0;
3200
3201 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3202
3203 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3204 {
3205 if (d_cache)
3206 {
3207 uint64_t cnt = d_cache->cnt;
3208
3209 uint64_t keyspace = cnt;
3210
3211 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3212 {
3213 keyspace *= data.kernel_rules_cnt;
3214 }
3215 else if (data.attack_kern == ATTACK_KERN_COMBI)
3216 {
3217 keyspace *= data.combs_cnt;
3218 }
3219
3220 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3221 if (data.quiet == 0) log_info ("");
3222
3223 hc_signal (sigHandler_default);
3224
3225 return (keyspace);
3226 }
3227 }
3228
3229 time_t now = 0;
3230 time_t prev = 0;
3231
3232 uint64_t comp = 0;
3233 uint64_t cnt = 0;
3234 uint64_t cnt2 = 0;
3235
3236 while (!feof (fd))
3237 {
3238 load_segment (wl_data, fd);
3239
3240 comp += wl_data->cnt;
3241
3242 uint32_t i = 0;
3243
3244 while (i < wl_data->cnt)
3245 {
3246 uint32_t len;
3247 uint32_t off;
3248
3249 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3250
3251 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3252 {
3253 char rule_buf_out[BLOCK_SIZE];
3254
3255 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3256
3257 int rule_len_out = -1;
3258
3259 if (len < BLOCK_SIZE)
3260 {
3261 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3262 }
3263
3264 if (rule_len_out < 0)
3265 {
3266 len = PW_MAX1;
3267 }
3268 else
3269 {
3270 len = rule_len_out;
3271 }
3272 }
3273
3274 if (len < PW_MAX1)
3275 {
3276 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3277 {
3278 cnt += data.kernel_rules_cnt;
3279 }
3280 else if (data.attack_kern == ATTACK_KERN_COMBI)
3281 {
3282 cnt += data.combs_cnt;
3283 }
3284
3285 d.cnt++;
3286 }
3287
3288 i += off;
3289
3290 cnt2++;
3291 }
3292
3293 time (&now);
3294
3295 if ((now - prev) == 0) continue;
3296
3297 float percent = (float) comp / (float) d.stat.st_size;
3298
3299 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3300
3301 time (&prev);
3302 }
3303
3304 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3305 if (data.quiet == 0) log_info ("");
3306
3307 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3308
3309 hc_signal (sigHandler_default);
3310
3311 return (cnt);
3312 }
3313
3314 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3315 {
3316 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3317 }
3318
3319 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
3320 {
3321 if (data.devices_status == STATUS_BYPASS) return 0;
3322
3323 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3324
3325 uint cache_cnt = pw_cache->cnt;
3326
3327 uint8_t *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3328
3329 memcpy (pw_hc1, pw_buf, pw_len);
3330
3331 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3332
3333 uint pws_cnt = device_param->pws_cnt;
3334
3335 cache_cnt++;
3336
3337 pw_t *pw = device_param->pws_buf + pws_cnt;
3338
3339 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3340
3341 pw->pw_len = pw_len;
3342
3343 pws_cnt++;
3344
3345 device_param->pws_cnt = pws_cnt;
3346 device_param->pw_cnt = pws_cnt * 1;
3347
3348 cache_cnt = 0;
3349
3350 pw_cache->cnt = cache_cnt;
3351
3352 return pws_cnt;
3353 }
3354
3355 static void *thread_monitor (void *p)
3356 {
3357 uint runtime_check = 0;
3358 uint remove_check = 0;
3359 uint status_check = 0;
3360 uint hwmon_check = 0;
3361 uint restore_check = 0;
3362
3363 uint restore_left = data.restore_timer;
3364 uint remove_left = data.remove_timer;
3365 uint status_left = data.status_timer;
3366
3367 // these variables are mainly used for fan control (AMD only)
3368
3369 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3370
3371 // temperature controller "loopback" values
3372
3373 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3374 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3375
3376 int temp_threshold = 1; // degrees celcius
3377
3378 int fan_speed_min = 15; // in percentage
3379 int fan_speed_max = 100;
3380
3381 time_t last_temp_check_time;
3382
3383 uint sleep_time = 1;
3384
3385 if (data.runtime)
3386 {
3387 runtime_check = 1;
3388 }
3389
3390 if (data.restore_timer)
3391 {
3392 restore_check = 1;
3393 }
3394
3395 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3396 {
3397 remove_check = 1;
3398 }
3399
3400 if (data.status == 1)
3401 {
3402 status_check = 1;
3403 }
3404
3405 if (data.gpu_temp_disable == 0)
3406 {
3407 time (&last_temp_check_time);
3408
3409 hwmon_check = 1;
3410 }
3411
3412 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3413 {
3414 return (p);
3415 }
3416
3417 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3418 {
3419 hc_sleep (sleep_time);
3420
3421 if (data.devices_status != STATUS_RUNNING) continue;
3422
3423 if (hwmon_check == 1)
3424 {
3425 hc_thread_mutex_lock (mux_adl);
3426
3427 time_t temp_check_time;
3428
3429 time (&temp_check_time);
3430
3431 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3432
3433 if (Ta == 0) Ta = 1;
3434
3435 for (uint i = 0; i < data.devices_cnt; i++)
3436 {
3437 if ((data.devices_param[i].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3438
3439 const int temperature = hm_get_temperature_with_device_id (i);
3440
3441 if (temperature > (int) data.gpu_temp_abort)
3442 {
3443 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", i + 1);
3444
3445 if (data.devices_status != STATUS_QUIT) myabort ();
3446
3447 break;
3448 }
3449
3450 const int gpu_temp_retain = data.gpu_temp_retain;
3451
3452 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3453 {
3454 if (data.hm_device[i].fan_supported == 1)
3455 {
3456 int temp_cur = temperature;
3457
3458 int temp_diff_new = gpu_temp_retain - temp_cur;
3459
3460 temp_diff_sum[i] = temp_diff_sum[i] + temp_diff_new;
3461
3462 // calculate Ta value (time difference in seconds between the last check and this check)
3463
3464 last_temp_check_time = temp_check_time;
3465
3466 float Kp = 1.8;
3467 float Ki = 0.005;
3468 float Kd = 6;
3469
3470 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3471
3472 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[i] + Kd * ((float)(temp_diff_new - temp_diff_old[i])) / Ta);
3473
3474 if (abs (fan_diff_required) >= temp_threshold)
3475 {
3476 const int fan_speed_cur = hm_get_fanspeed_with_device_id (i);
3477
3478 int fan_speed_level = fan_speed_cur;
3479
3480 if (fan_speed_chgd[i] == 0) fan_speed_level = temp_cur;
3481
3482 int fan_speed_new = fan_speed_level - fan_diff_required;
3483
3484 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3485 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3486
3487 if (fan_speed_new != fan_speed_cur)
3488 {
3489 int freely_change_fan_speed = (fan_speed_chgd[i] == 1);
3490 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3491
3492 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3493 {
3494 hm_set_fanspeed_with_device_id_amd (i, fan_speed_new);
3495
3496 fan_speed_chgd[i] = 1;
3497 }
3498
3499 temp_diff_old[i] = temp_diff_new;
3500 }
3501 }
3502 }
3503 }
3504 }
3505
3506 hc_thread_mutex_unlock (mux_adl);
3507 }
3508
3509 if (restore_check == 1)
3510 {
3511 restore_left--;
3512
3513 if (restore_left == 0)
3514 {
3515 if (data.restore_disable == 0) cycle_restore ();
3516
3517 restore_left = data.restore_timer;
3518 }
3519 }
3520
3521 if ((runtime_check == 1) && (data.runtime_start > 0))
3522 {
3523 time_t runtime_cur;
3524
3525 time (&runtime_cur);
3526
3527 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3528
3529 if (runtime_left <= 0)
3530 {
3531 if (data.benchmark == 0)
3532 {
3533 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3534 }
3535
3536 if (data.devices_status != STATUS_QUIT) myabort ();
3537 }
3538 }
3539
3540 if (remove_check == 1)
3541 {
3542 remove_left--;
3543
3544 if (remove_left == 0)
3545 {
3546 if (data.digests_saved != data.digests_done)
3547 {
3548 data.digests_saved = data.digests_done;
3549
3550 save_hash ();
3551 }
3552
3553 remove_left = data.remove_timer;
3554 }
3555 }
3556
3557 if (status_check == 1)
3558 {
3559 status_left--;
3560
3561 if (status_left == 0)
3562 {
3563 hc_thread_mutex_lock (mux_display);
3564
3565 if (data.quiet == 0) clear_prompt ();
3566
3567 if (data.quiet == 0) log_info ("");
3568
3569 status_display ();
3570
3571 if (data.quiet == 0) log_info ("");
3572
3573 hc_thread_mutex_unlock (mux_display);
3574
3575 status_left = data.status_timer;
3576 }
3577 }
3578 }
3579
3580 myfree (fan_speed_chgd);
3581
3582 myfree (temp_diff_old);
3583 myfree (temp_diff_sum);
3584
3585 p = NULL;
3586
3587 return (p);
3588 }
3589
3590 static void *thread_outfile_remove (void *p)
3591 {
3592 // some hash-dependent constants
3593 char *outfile_dir = data.outfile_check_directory;
3594 uint dgst_size = data.dgst_size;
3595 uint isSalted = data.isSalted;
3596 uint esalt_size = data.esalt_size;
3597 uint hash_mode = data.hash_mode;
3598
3599 uint outfile_check_timer = data.outfile_check_timer;
3600
3601 char separator = data.separator;
3602
3603 // some hash-dependent functions
3604 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3605 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3606
3607 // buffers
3608 hash_t hash_buf;
3609
3610 memset (&hash_buf, 0, sizeof (hash_buf));
3611
3612 hash_buf.digest = mymalloc (dgst_size);
3613
3614 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3615
3616 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3617
3618 uint digest_buf[64];
3619
3620 outfile_data_t *out_info = NULL;
3621
3622 char **out_files = NULL;
3623
3624 time_t folder_mtime = 0;
3625
3626 int out_cnt = 0;
3627
3628 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3629
3630 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3631 {
3632 hc_sleep (1);
3633
3634 if (data.devices_status != STATUS_RUNNING) continue;
3635
3636 check_left--;
3637
3638 if (check_left == 0)
3639 {
3640 struct stat outfile_check_stat;
3641
3642 if (stat (outfile_dir, &outfile_check_stat) == 0)
3643 {
3644 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3645
3646 if (is_dir == 1)
3647 {
3648 if (outfile_check_stat.st_mtime > folder_mtime)
3649 {
3650 char **out_files_new = scan_directory (outfile_dir);
3651
3652 int out_cnt_new = count_dictionaries (out_files_new);
3653
3654 outfile_data_t *out_info_new = NULL;
3655
3656 if (out_cnt_new > 0)
3657 {
3658 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3659
3660 for (int i = 0; i < out_cnt_new; i++)
3661 {
3662 out_info_new[i].file_name = out_files_new[i];
3663
3664 // check if there are files that we have seen/checked before (and not changed)
3665
3666 for (int j = 0; j < out_cnt; j++)
3667 {
3668 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3669 {
3670 struct stat outfile_stat;
3671
3672 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3673 {
3674 if (outfile_stat.st_ctime == out_info[j].ctime)
3675 {
3676 out_info_new[i].ctime = out_info[j].ctime;
3677 out_info_new[i].seek = out_info[j].seek;
3678 }
3679 }
3680 }
3681 }
3682 }
3683 }
3684
3685 local_free (out_info);
3686 local_free (out_files);
3687
3688 out_files = out_files_new;
3689 out_cnt = out_cnt_new;
3690 out_info = out_info_new;
3691
3692 folder_mtime = outfile_check_stat.st_mtime;
3693 }
3694
3695 for (int j = 0; j < out_cnt; j++)
3696 {
3697 FILE *fp = fopen (out_info[j].file_name, "rb");
3698
3699 if (fp != NULL)
3700 {
3701 //hc_thread_mutex_lock (mux_display);
3702
3703 #ifdef _POSIX
3704 struct stat outfile_stat;
3705
3706 fstat (fileno (fp), &outfile_stat);
3707 #endif
3708
3709 #ifdef _WIN
3710 struct stat64 outfile_stat;
3711
3712 _fstat64 (fileno (fp), &outfile_stat);
3713 #endif
3714
3715 if (outfile_stat.st_ctime > out_info[j].ctime)
3716 {
3717 out_info[j].ctime = outfile_stat.st_ctime;
3718 out_info[j].seek = 0;
3719 }
3720
3721 fseek (fp, out_info[j].seek, SEEK_SET);
3722
3723 while (!feof (fp))
3724 {
3725 char line_buf[BUFSIZ];
3726
3727 memset (line_buf, 0, BUFSIZ);
3728
3729 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3730
3731 if (ptr == NULL) break;
3732
3733 int line_len = strlen (line_buf);
3734
3735 if (line_len <= 0) continue;
3736
3737 int iter = MAX_CUT_TRIES;
3738
3739 for (uint i = line_len - 1; i && iter; i--, line_len--)
3740 {
3741 if (line_buf[i] != separator) continue;
3742
3743 int parser_status = PARSER_OK;
3744
3745 if ((hash_mode != 2500) && (hash_mode != 6800))
3746 {
3747 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3748 }
3749
3750 uint found = 0;
3751
3752 if (parser_status == PARSER_OK)
3753 {
3754 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3755 {
3756 if (data.salts_shown[salt_pos] == 1) continue;
3757
3758 salt_t *salt_buf = &data.salts_buf[salt_pos];
3759
3760 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3761 {
3762 uint idx = salt_buf->digests_offset + digest_pos;
3763
3764 if (data.digests_shown[idx] == 1) continue;
3765
3766 uint cracked = 0;
3767
3768 if (hash_mode == 6800)
3769 {
3770 if (i == salt_buf->salt_len)
3771 {
3772 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3773 }
3774 }
3775 else if (hash_mode == 2500)
3776 {
3777 // BSSID : MAC1 : MAC2 (:plain)
3778 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3779 {
3780 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3781
3782 if (!cracked) continue;
3783
3784 // now compare MAC1 and MAC2 too, since we have this additional info
3785 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3786 char *mac2_pos = mac1_pos + 12 + 1;
3787
3788 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3789 wpa_t *wpa = &wpas[salt_pos];
3790
3791 uint pke[25];
3792
3793 char *pke_ptr = (char *) pke;
3794
3795 for (uint i = 0; i < 25; i++)
3796 {
3797 pke[i] = byte_swap_32 (wpa->pke[i]);
3798 }
3799
3800 unsigned char mac1[6];
3801 unsigned char mac2[6];
3802
3803 memcpy (mac1, pke_ptr + 23, 6);
3804 memcpy (mac2, pke_ptr + 29, 6);
3805
3806 // compare hex string(s) vs binary MAC address(es)
3807
3808 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3809 {
3810 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
3811 {
3812 cracked = 0;
3813 break;
3814 }
3815 }
3816
3817 // early skip ;)
3818 if (!cracked) continue;
3819
3820 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3821 {
3822 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
3823 {
3824 cracked = 0;
3825 break;
3826 }
3827 }
3828 }
3829 }
3830 else
3831 {
3832 char *digests_buf_ptr = (char *) data.digests_buf;
3833
3834 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3835
3836 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3837 }
3838
3839 if (cracked == 1)
3840 {
3841 found = 1;
3842
3843 data.digests_shown[idx] = 1;
3844
3845 data.digests_done++;
3846
3847 salt_buf->digests_done++;
3848
3849 if (salt_buf->digests_done == salt_buf->digests_cnt)
3850 {
3851 data.salts_shown[salt_pos] = 1;
3852
3853 data.salts_done++;
3854
3855 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3856 }
3857 }
3858 }
3859
3860 if (data.devices_status == STATUS_CRACKED) break;
3861 }
3862 }
3863
3864 if (found) break;
3865
3866 if (data.devices_status == STATUS_CRACKED) break;
3867
3868 iter--;
3869 }
3870
3871 if (data.devices_status == STATUS_CRACKED) break;
3872 }
3873
3874 out_info[j].seek = ftell (fp);
3875
3876 //hc_thread_mutex_unlock (mux_display);
3877
3878 fclose (fp);
3879 }
3880 }
3881 }
3882 }
3883
3884 check_left = outfile_check_timer;
3885 }
3886 }
3887
3888 if (esalt_size) local_free (hash_buf.esalt);
3889
3890 if (isSalted) local_free (hash_buf.salt);
3891
3892 local_free (hash_buf.digest);
3893
3894 local_free (out_info);
3895
3896 local_free (out_files);
3897
3898 p = NULL;
3899
3900 return (p);
3901 }
3902
3903 static uint get_work (hc_device_param_t *device_param, const uint64_t max)
3904 {
3905 hc_thread_mutex_lock (mux_dispatcher);
3906
3907 const uint64_t words_cur = data.words_cur;
3908 const uint64_t words_base = (data.limit == 0) ? data.words_base : data.limit;
3909
3910 device_param->words_off = words_cur;
3911
3912 const uint64_t words_left = words_base - words_cur;
3913
3914 if (data.kernel_blocks_all > words_left)
3915 {
3916 if (data.kernel_blocks_div == 0)
3917 {
3918 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3919 }
3920 }
3921
3922 if (data.kernel_blocks_div)
3923 {
3924 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3925 {
3926 const uint32_t kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3927 const uint32_t kernel_power_new = kernel_blocks_new;
3928
3929 if (kernel_blocks_new < device_param->kernel_blocks)
3930 {
3931 device_param->kernel_blocks = kernel_blocks_new;
3932 device_param->kernel_power = kernel_power_new;
3933 }
3934 }
3935 }
3936
3937 const uint kernel_blocks = device_param->kernel_blocks;
3938
3939 uint work = MIN (words_left, kernel_blocks);
3940
3941 work = MIN (work, max);
3942
3943 data.words_cur += work;
3944
3945 hc_thread_mutex_unlock (mux_dispatcher);
3946
3947 return work;
3948 }
3949
3950 static void *thread_calc_stdin (void *p)
3951 {
3952 hc_device_param_t *device_param = (hc_device_param_t *) p;
3953
3954 const uint attack_kern = data.attack_kern;
3955
3956 const uint kernel_blocks = device_param->kernel_blocks;
3957
3958 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3959 {
3960 hc_thread_mutex_lock (mux_dispatcher);
3961
3962 if (feof (stdin) != 0)
3963 {
3964 hc_thread_mutex_unlock (mux_dispatcher);
3965
3966 break;
3967 }
3968
3969 uint words_cur = 0;
3970
3971 while (words_cur < kernel_blocks)
3972 {
3973 char buf[BUFSIZ];
3974
3975 char *line_buf = fgets (buf, sizeof (buf), stdin);
3976
3977 if (line_buf == NULL) break;
3978
3979 uint line_len = in_superchop (line_buf);
3980
3981 line_len = convert_from_hex (line_buf, line_len);
3982
3983 // post-process rule engine
3984
3985 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3986 {
3987 char rule_buf_out[BLOCK_SIZE];
3988
3989 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3990
3991 int rule_len_out = -1;
3992
3993 if (line_len < BLOCK_SIZE)
3994 {
3995 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
3996 }
3997
3998 if (rule_len_out < 0) continue;
3999
4000 line_buf = rule_buf_out;
4001 line_len = rule_len_out;
4002 }
4003
4004 if (line_len > PW_MAX)
4005 {
4006 continue;
4007 }
4008
4009 if (attack_kern == ATTACK_KERN_STRAIGHT)
4010 {
4011 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4012 {
4013 hc_thread_mutex_lock (mux_counter);
4014
4015 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4016 {
4017 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4018 }
4019
4020 hc_thread_mutex_unlock (mux_counter);
4021
4022 continue;
4023 }
4024 }
4025 else if (attack_kern == ATTACK_KERN_COMBI)
4026 {
4027 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4028 // since we still need to combine the plains
4029
4030 if (line_len > data.pw_max)
4031 {
4032 hc_thread_mutex_lock (mux_counter);
4033
4034 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4035 {
4036 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4037 }
4038
4039 hc_thread_mutex_unlock (mux_counter);
4040
4041 continue;
4042 }
4043 }
4044
4045 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4046
4047 words_cur++;
4048
4049 if (data.devices_status == STATUS_CRACKED) break;
4050 if (data.devices_status == STATUS_ABORTED) break;
4051 if (data.devices_status == STATUS_QUIT) break;
4052 if (data.devices_status == STATUS_BYPASS) break;
4053 }
4054
4055 hc_thread_mutex_unlock (mux_dispatcher);
4056
4057 if (data.devices_status == STATUS_CRACKED) break;
4058 if (data.devices_status == STATUS_ABORTED) break;
4059 if (data.devices_status == STATUS_QUIT) break;
4060 if (data.devices_status == STATUS_BYPASS) break;
4061
4062 // we need 2 flushing because we have two independant caches and it can occur
4063 // that one buffer is already at threshold plus for that length also exists
4064 // more data in the 2nd buffer so it would overflow
4065
4066 // flush session 1
4067
4068 {
4069 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4070 {
4071 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4072
4073 const uint pw_cache_cnt = pw_cache->cnt;
4074
4075 if (pw_cache_cnt == 0) continue;
4076
4077 pw_cache->cnt = 0;
4078
4079 uint pws_cnt = device_param->pws_cnt;
4080
4081 pw_t *pw = device_param->pws_buf + pws_cnt;
4082
4083 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4084
4085 pw->pw_len = pw_len;
4086
4087 uint pw_cnt = device_param->pw_cnt;
4088
4089 pw_cnt += pw_cache_cnt;
4090
4091 device_param->pw_cnt = pw_cnt;
4092
4093 pws_cnt++;
4094
4095 device_param->pws_cnt = pws_cnt;
4096
4097 if (pws_cnt == device_param->kernel_power_user) break;
4098 }
4099
4100 const uint pw_cnt = device_param->pw_cnt;
4101 const uint pws_cnt = device_param->pws_cnt;
4102
4103 if (pws_cnt)
4104 {
4105 run_copy (device_param, pws_cnt);
4106
4107 run_cracker (device_param, pw_cnt, pws_cnt);
4108
4109 device_param->pw_cnt = 0;
4110 device_param->pws_cnt = 0;
4111 }
4112 }
4113
4114 // flush session 2
4115
4116 {
4117 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4118 {
4119 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4120
4121 const uint pw_cache_cnt = pw_cache->cnt;
4122
4123 if (pw_cache_cnt == 0) continue;
4124
4125 pw_cache->cnt = 0;
4126
4127 uint pws_cnt = device_param->pws_cnt;
4128
4129 pw_t *pw = device_param->pws_buf + pws_cnt;
4130
4131 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4132
4133 pw->pw_len = pw_len;
4134
4135 uint pw_cnt = device_param->pw_cnt;
4136
4137 pw_cnt += pw_cache_cnt;
4138
4139 device_param->pw_cnt = pw_cnt;
4140
4141 pws_cnt++;
4142
4143 device_param->pws_cnt = pws_cnt;
4144 }
4145
4146 const uint pw_cnt = device_param->pw_cnt;
4147 const uint pws_cnt = device_param->pws_cnt;
4148
4149 if (pws_cnt)
4150 {
4151 run_copy (device_param, pws_cnt);
4152
4153 run_cracker (device_param, pw_cnt, pws_cnt);
4154
4155 device_param->pw_cnt = 0;
4156 device_param->pws_cnt = 0;
4157 }
4158 }
4159 }
4160
4161 return NULL;
4162 }
4163
4164 static void *thread_calc (void *p)
4165 {
4166 hc_device_param_t *device_param = (hc_device_param_t *) p;
4167
4168 const uint attack_mode = data.attack_mode;
4169 const uint attack_kern = data.attack_kern;
4170
4171 if (attack_mode == ATTACK_MODE_BF)
4172 {
4173 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4174 {
4175 const uint work = get_work (device_param, -1);
4176
4177 if (work == 0) break;
4178
4179 const uint64_t words_off = device_param->words_off;
4180 const uint64_t words_fin = words_off + work;
4181
4182 const uint pw_cnt = work;
4183 const uint pws_cnt = work;
4184
4185 device_param->pw_cnt = pw_cnt;
4186 device_param->pws_cnt = pws_cnt;
4187
4188 if (pws_cnt)
4189 {
4190 run_copy (device_param, pws_cnt);
4191
4192 run_cracker (device_param, pw_cnt, pws_cnt);
4193
4194 device_param->pw_cnt = 0;
4195 device_param->pws_cnt = 0;
4196 }
4197
4198 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4199
4200 if (data.devices_status == STATUS_CRACKED) break;
4201 if (data.devices_status == STATUS_ABORTED) break;
4202 if (data.devices_status == STATUS_QUIT) break;
4203 if (data.devices_status == STATUS_BYPASS) break;
4204
4205 device_param->words_done = words_fin;
4206 }
4207 }
4208 else
4209 {
4210 const uint segment_size = data.segment_size;
4211
4212 char *dictfile = data.dictfile;
4213
4214 if (attack_mode == ATTACK_MODE_COMBI)
4215 {
4216 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4217 {
4218 dictfile = data.dictfile2;
4219 }
4220 }
4221
4222 FILE *fd = fopen (dictfile, "rb");
4223
4224 if (fd == NULL)
4225 {
4226 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4227
4228 return NULL;
4229 }
4230
4231 if (attack_mode == ATTACK_MODE_COMBI)
4232 {
4233 const uint combs_mode = data.combs_mode;
4234
4235 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4236 {
4237 const char *dictfilec = data.dictfile2;
4238
4239 FILE *combs_fp = fopen (dictfilec, "rb");
4240
4241 if (combs_fp == NULL)
4242 {
4243 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4244
4245 fclose (fd);
4246
4247 return NULL;
4248 }
4249
4250 device_param->combs_fp = combs_fp;
4251 }
4252 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4253 {
4254 const char *dictfilec = data.dictfile;
4255
4256 FILE *combs_fp = fopen (dictfilec, "rb");
4257
4258 if (combs_fp == NULL)
4259 {
4260 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4261
4262 fclose (fd);
4263
4264 return NULL;
4265 }
4266
4267 device_param->combs_fp = combs_fp;
4268 }
4269 }
4270
4271 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4272
4273 wl_data->buf = (char *) mymalloc (segment_size);
4274 wl_data->avail = segment_size;
4275 wl_data->incr = segment_size;
4276 wl_data->cnt = 0;
4277 wl_data->pos = 0;
4278
4279 uint64_t words_cur = 0;
4280
4281 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4282 {
4283 uint64_t words_off = 0;
4284 uint64_t words_fin = 0;
4285
4286 uint64_t max = -1;
4287
4288 while (max)
4289 {
4290 const uint work = get_work (device_param, max);
4291
4292 if (work == 0) break;
4293
4294 words_off = device_param->words_off;
4295 words_fin = words_off + work;
4296
4297 char *line_buf;
4298 uint line_len;
4299
4300 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4301
4302 max = 0;
4303
4304 for ( ; words_cur < words_fin; words_cur++)
4305 {
4306 get_next_word (wl_data, fd, &line_buf, &line_len);
4307
4308 line_len = convert_from_hex (line_buf, line_len);
4309
4310 // post-process rule engine
4311
4312 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4313 {
4314 char rule_buf_out[BLOCK_SIZE];
4315
4316 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4317
4318 int rule_len_out = -1;
4319
4320 if (line_len < BLOCK_SIZE)
4321 {
4322 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4323 }
4324
4325 if (rule_len_out < 0) continue;
4326
4327 line_buf = rule_buf_out;
4328 line_len = rule_len_out;
4329 }
4330
4331 if (attack_kern == ATTACK_KERN_STRAIGHT)
4332 {
4333 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4334 {
4335 max++;
4336
4337 hc_thread_mutex_lock (mux_counter);
4338
4339 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4340 {
4341 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4342 }
4343
4344 hc_thread_mutex_unlock (mux_counter);
4345
4346 continue;
4347 }
4348 }
4349 else if (attack_kern == ATTACK_KERN_COMBI)
4350 {
4351 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4352 // since we still need to combine the plains
4353
4354 if (line_len > data.pw_max)
4355 {
4356 max++;
4357
4358 hc_thread_mutex_lock (mux_counter);
4359
4360 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4361 {
4362 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4363 }
4364
4365 hc_thread_mutex_unlock (mux_counter);
4366
4367 continue;
4368 }
4369 }
4370
4371 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4372
4373 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4374
4375 if (data.devices_status == STATUS_CRACKED) break;
4376 if (data.devices_status == STATUS_ABORTED) break;
4377 if (data.devices_status == STATUS_QUIT) break;
4378 if (data.devices_status == STATUS_BYPASS) break;
4379 }
4380
4381 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4382
4383 if (data.devices_status == STATUS_CRACKED) break;
4384 if (data.devices_status == STATUS_ABORTED) break;
4385 if (data.devices_status == STATUS_QUIT) break;
4386 if (data.devices_status == STATUS_BYPASS) break;
4387 }
4388
4389 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4390
4391 if (data.devices_status == STATUS_CRACKED) break;
4392 if (data.devices_status == STATUS_ABORTED) break;
4393 if (data.devices_status == STATUS_QUIT) break;
4394 if (data.devices_status == STATUS_BYPASS) break;
4395
4396 // we need 2 flushing because we have two independant caches and it can occur
4397 // that one buffer is already at threshold plus for that length also exists
4398 // more data in the 2nd buffer so it would overflow
4399
4400 //
4401 // flush session 1
4402 //
4403
4404 {
4405 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4406 {
4407 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4408
4409 const uint pw_cache_cnt = pw_cache->cnt;
4410
4411 if (pw_cache_cnt == 0) continue;
4412
4413 pw_cache->cnt = 0;
4414
4415 uint pws_cnt = device_param->pws_cnt;
4416
4417 pw_t *pw = device_param->pws_buf + pws_cnt;
4418
4419 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4420
4421 pw->pw_len = pw_len;
4422
4423 uint pw_cnt = device_param->pw_cnt;
4424
4425 pw_cnt += pw_cache_cnt;
4426
4427 device_param->pw_cnt = pw_cnt;
4428
4429 pws_cnt++;
4430
4431 device_param->pws_cnt = pws_cnt;
4432
4433 if (pws_cnt == device_param->kernel_power_user) break;
4434 }
4435
4436 const uint pw_cnt = device_param->pw_cnt;
4437 const uint pws_cnt = device_param->pws_cnt;
4438
4439 if (pws_cnt)
4440 {
4441 run_copy (device_param, pws_cnt);
4442
4443 run_cracker (device_param, pw_cnt, pws_cnt);
4444
4445 device_param->pw_cnt = 0;
4446 device_param->pws_cnt = 0;
4447 }
4448
4449 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4450
4451 if (data.devices_status == STATUS_CRACKED) break;
4452 if (data.devices_status == STATUS_ABORTED) break;
4453 if (data.devices_status == STATUS_QUIT) break;
4454 if (data.devices_status == STATUS_BYPASS) break;
4455 }
4456
4457 //
4458 // flush session 2
4459 //
4460
4461 {
4462 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4463 {
4464 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4465
4466 const uint pw_cache_cnt = pw_cache->cnt;
4467
4468 if (pw_cache_cnt == 0) continue;
4469
4470 pw_cache->cnt = 0;
4471
4472 uint pws_cnt = device_param->pws_cnt;
4473
4474 pw_t *pw = device_param->pws_buf + pws_cnt;
4475
4476 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4477
4478 pw->pw_len = pw_len;
4479
4480 uint pw_cnt = device_param->pw_cnt;
4481
4482 pw_cnt += pw_cache_cnt;
4483
4484 device_param->pw_cnt = pw_cnt;
4485
4486 pws_cnt++;
4487
4488 device_param->pws_cnt = pws_cnt;
4489 }
4490
4491 const uint pw_cnt = device_param->pw_cnt;
4492 const uint pws_cnt = device_param->pws_cnt;
4493
4494 if (pws_cnt)
4495 {
4496 run_copy (device_param, pws_cnt);
4497
4498 run_cracker (device_param, pw_cnt, pws_cnt);
4499
4500 device_param->pw_cnt = 0;
4501 device_param->pws_cnt = 0;
4502 }
4503
4504 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4505
4506 if (data.devices_status == STATUS_CRACKED) break;
4507 if (data.devices_status == STATUS_ABORTED) break;
4508 if (data.devices_status == STATUS_QUIT) break;
4509 if (data.devices_status == STATUS_BYPASS) break;
4510 }
4511
4512 if (words_fin == 0) break;
4513
4514 device_param->words_done = words_fin;
4515 }
4516
4517 if (attack_mode == ATTACK_MODE_COMBI)
4518 {
4519 fclose (device_param->combs_fp);
4520 }
4521
4522 free (wl_data->buf);
4523 free (wl_data);
4524
4525 fclose (fd);
4526 }
4527
4528 return NULL;
4529 }
4530
4531 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4532 {
4533 salt_t *salt_buf = &data.salts_buf[salt_pos];
4534
4535 device_param->kernel_params_buf32[24] = salt_pos;
4536 device_param->kernel_params_buf32[27] = 1;
4537 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4538 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4539 device_param->kernel_params_buf32[30] = 0;
4540 device_param->kernel_params_buf32[31] = 1;
4541
4542 char *dictfile_old = data.dictfile;
4543
4544 const char *weak_hash_check = "weak-hash-check";
4545
4546 data.dictfile = (char *) weak_hash_check;
4547
4548 /**
4549 * run the kernel
4550 */
4551
4552 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4553 {
4554 run_kernel (KERN_RUN_1, device_param, 1);
4555 }
4556 else
4557 {
4558 run_kernel (KERN_RUN_1, device_param, 1);
4559
4560 const uint iter = salt_buf->salt_iter;
4561
4562 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4563 {
4564 uint loop_left = iter - loop_pos;
4565
4566 loop_left = MIN (loop_left, kernel_loops);
4567
4568 device_param->kernel_params_buf32[25] = loop_pos;
4569 device_param->kernel_params_buf32[26] = loop_left;
4570
4571 run_kernel (KERN_RUN_2, device_param, 1);
4572 }
4573
4574 run_kernel (KERN_RUN_3, device_param, 1);
4575 }
4576
4577 /**
4578 * result
4579 */
4580
4581 check_cracked (device_param, salt_pos);
4582
4583 /**
4584 * cleanup
4585 */
4586
4587 device_param->kernel_params_buf32[24] = 0;
4588 device_param->kernel_params_buf32[25] = 0;
4589 device_param->kernel_params_buf32[26] = 0;
4590 device_param->kernel_params_buf32[27] = 0;
4591 device_param->kernel_params_buf32[28] = 0;
4592 device_param->kernel_params_buf32[29] = 0;
4593 device_param->kernel_params_buf32[30] = 0;
4594 device_param->kernel_params_buf32[31] = 0;
4595
4596 data.dictfile = dictfile_old;
4597 }
4598
4599 // hlfmt hashcat
4600
4601 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4602 {
4603 if (data.username == 0)
4604 {
4605 *hashbuf_pos = line_buf;
4606 *hashbuf_len = line_len;
4607 }
4608 else
4609 {
4610 char *pos = line_buf;
4611 int len = line_len;
4612
4613 for (int i = 0; i < line_len; i++, pos++, len--)
4614 {
4615 if (line_buf[i] == data.separator)
4616 {
4617 pos++;
4618
4619 len--;
4620
4621 break;
4622 }
4623 }
4624
4625 *hashbuf_pos = pos;
4626 *hashbuf_len = len;
4627 }
4628 }
4629
4630 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4631 {
4632 char *pos = NULL;
4633 int len = 0;
4634
4635 int sep_cnt = 0;
4636
4637 for (int i = 0; i < line_len; i++)
4638 {
4639 if (line_buf[i] == data.separator)
4640 {
4641 sep_cnt++;
4642
4643 continue;
4644 }
4645
4646 if (sep_cnt == 0)
4647 {
4648 if (pos == NULL) pos = line_buf + i;
4649
4650 len++;
4651 }
4652 }
4653
4654 *userbuf_pos = pos;
4655 *userbuf_len = len;
4656 }
4657
4658 // hlfmt pwdump
4659
4660 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4661 {
4662 int sep_cnt = 0;
4663
4664 int sep2_len = 0;
4665 int sep3_len = 0;
4666
4667 for (int i = 0; i < line_len; i++)
4668 {
4669 if (line_buf[i] == ':')
4670 {
4671 sep_cnt++;
4672
4673 continue;
4674 }
4675
4676 if (sep_cnt == 2) sep2_len++;
4677 if (sep_cnt == 3) sep3_len++;
4678 }
4679
4680 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4681
4682 return 0;
4683 }
4684
4685 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4686 {
4687 char *pos = NULL;
4688 int len = 0;
4689
4690 int sep_cnt = 0;
4691
4692 for (int i = 0; i < line_len; i++)
4693 {
4694 if (line_buf[i] == ':')
4695 {
4696 sep_cnt++;
4697
4698 continue;
4699 }
4700
4701 if (data.hash_mode == 1000)
4702 {
4703 if (sep_cnt == 3)
4704 {
4705 if (pos == NULL) pos = line_buf + i;
4706
4707 len++;
4708 }
4709 }
4710 else if (data.hash_mode == 3000)
4711 {
4712 if (sep_cnt == 2)
4713 {
4714 if (pos == NULL) pos = line_buf + i;
4715
4716 len++;
4717 }
4718 }
4719 }
4720
4721 *hashbuf_pos = pos;
4722 *hashbuf_len = len;
4723 }
4724
4725 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4726 {
4727 char *pos = NULL;
4728 int len = 0;
4729
4730 int sep_cnt = 0;
4731
4732 for (int i = 0; i < line_len; i++)
4733 {
4734 if (line_buf[i] == ':')
4735 {
4736 sep_cnt++;
4737
4738 continue;
4739 }
4740
4741 if (sep_cnt == 0)
4742 {
4743 if (pos == NULL) pos = line_buf + i;
4744
4745 len++;
4746 }
4747 }
4748
4749 *userbuf_pos = pos;
4750 *userbuf_len = len;
4751 }
4752
4753 // hlfmt passwd
4754
4755 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4756 {
4757 int sep_cnt = 0;
4758
4759 char sep5_first = 0;
4760 char sep6_first = 0;
4761
4762 for (int i = 0; i < line_len; i++)
4763 {
4764 if (line_buf[i] == ':')
4765 {
4766 sep_cnt++;
4767
4768 continue;
4769 }
4770
4771 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4772 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4773 }
4774
4775 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4776
4777 return 0;
4778 }
4779
4780 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4781 {
4782 char *pos = NULL;
4783 int len = 0;
4784
4785 int sep_cnt = 0;
4786
4787 for (int i = 0; i < line_len; i++)
4788 {
4789 if (line_buf[i] == ':')
4790 {
4791 sep_cnt++;
4792
4793 continue;
4794 }
4795
4796 if (sep_cnt == 1)
4797 {
4798 if (pos == NULL) pos = line_buf + i;
4799
4800 len++;
4801 }
4802 }
4803
4804 *hashbuf_pos = pos;
4805 *hashbuf_len = len;
4806 }
4807
4808 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4809 {
4810 char *pos = NULL;
4811 int len = 0;
4812
4813 int sep_cnt = 0;
4814
4815 for (int i = 0; i < line_len; i++)
4816 {
4817 if (line_buf[i] == ':')
4818 {
4819 sep_cnt++;
4820
4821 continue;
4822 }
4823
4824 if (sep_cnt == 0)
4825 {
4826 if (pos == NULL) pos = line_buf + i;
4827
4828 len++;
4829 }
4830 }
4831
4832 *userbuf_pos = pos;
4833 *userbuf_len = len;
4834 }
4835
4836 // hlfmt shadow
4837
4838 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4839 {
4840 int sep_cnt = 0;
4841
4842 for (int i = 0; i < line_len; i++)
4843 {
4844 if (line_buf[i] == ':') sep_cnt++;
4845 }
4846
4847 if (sep_cnt == 8) return 1;
4848
4849 return 0;
4850 }
4851
4852 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4853 {
4854 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4855 }
4856
4857 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4858 {
4859 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4860 }
4861
4862 // hlfmt main
4863
4864 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4865 {
4866 switch (hashfile_format)
4867 {
4868 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4869 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4870 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4871 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4872 }
4873 }
4874
4875 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4876 {
4877 switch (hashfile_format)
4878 {
4879 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4880 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4881 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4882 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4883 }
4884 }
4885
4886 static uint hlfmt_detect (FILE *fp, uint max_check)
4887 {
4888 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4889
4890 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4891 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4892
4893 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4894
4895 uint num_check = 0;
4896
4897 while (!feof (fp))
4898 {
4899 char line_buf[BUFSIZ];
4900
4901 int line_len = fgetl (fp, line_buf);
4902
4903 if (line_len == 0) continue;
4904
4905 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4906 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4907 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4908
4909 if (num_check == max_check) break;
4910
4911 num_check++;
4912 }
4913
4914 uint hashlist_format = HLFMT_HASHCAT;
4915
4916 for (int i = 1; i < HLFMTS_CNT; i++)
4917 {
4918 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4919
4920 hashlist_format = i;
4921 }
4922
4923 free (formats_cnt);
4924
4925 return hashlist_format;
4926 }
4927
4928 /**
4929 * some further helper function
4930 */
4931
4932 // wrapper around mymalloc for ADL
4933
4934 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4935 {
4936 return mymalloc (iSize);
4937 }
4938
4939 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const uint64_t collisions_max)
4940 {
4941 uint64_t collisions = 0;
4942
4943 const uint dgst_pos0 = data.dgst_pos0;
4944 const uint dgst_pos1 = data.dgst_pos1;
4945 const uint dgst_pos2 = data.dgst_pos2;
4946 const uint dgst_pos3 = data.dgst_pos3;
4947
4948 memset (bitmap_a, 0, bitmap_size);
4949 memset (bitmap_b, 0, bitmap_size);
4950 memset (bitmap_c, 0, bitmap_size);
4951 memset (bitmap_d, 0, bitmap_size);
4952
4953 for (uint i = 0; i < digests_cnt; i++)
4954 {
4955 uint *digest_ptr = (uint *) digests_buf_ptr;
4956
4957 digests_buf_ptr += dgst_size;
4958
4959 const uint val0 = 1 << (digest_ptr[dgst_pos0] & 0x1f);
4960 const uint val1 = 1 << (digest_ptr[dgst_pos1] & 0x1f);
4961 const uint val2 = 1 << (digest_ptr[dgst_pos2] & 0x1f);
4962 const uint val3 = 1 << (digest_ptr[dgst_pos3] & 0x1f);
4963
4964 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4965 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4966 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4967 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4968
4969 if (bitmap_a[idx0] & val0) collisions++;
4970 if (bitmap_b[idx1] & val1) collisions++;
4971 if (bitmap_c[idx2] & val2) collisions++;
4972 if (bitmap_d[idx3] & val3) collisions++;
4973
4974 bitmap_a[idx0] |= val0;
4975 bitmap_b[idx1] |= val1;
4976 bitmap_c[idx2] |= val2;
4977 bitmap_d[idx3] |= val3;
4978
4979 if (collisions >= collisions_max) return 0x7fffffff;
4980 }
4981
4982 return collisions;
4983 }
4984
4985 /**
4986 * main
4987 */
4988
4989 int main (int argc, char **argv)
4990 {
4991 /**
4992 * To help users a bit
4993 */
4994
4995 char *compute = getenv ("COMPUTE");
4996
4997 if (compute)
4998 {
4999 char display[100];
5000
5001 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5002
5003 putenv (display);
5004 }
5005 else
5006 {
5007 if (getenv ("DISPLAY") == NULL)
5008 putenv ((char *) "DISPLAY=:0");
5009 }
5010
5011 /*
5012 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5013 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5014
5015 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5016 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5017 */
5018
5019 /**
5020 * Real init
5021 */
5022
5023 memset (&data, 0, sizeof (hc_global_data_t));
5024
5025 time_t proc_start;
5026
5027 time (&proc_start);
5028
5029 data.proc_start = proc_start;
5030
5031 int myargc = argc;
5032 char **myargv = argv;
5033
5034 hc_thread_mutex_init (mux_dispatcher);
5035 hc_thread_mutex_init (mux_counter);
5036 hc_thread_mutex_init (mux_display);
5037 hc_thread_mutex_init (mux_adl);
5038
5039 /**
5040 * commandline parameters
5041 */
5042
5043 uint usage = USAGE;
5044 uint version = VERSION;
5045 uint quiet = QUIET;
5046 uint benchmark = BENCHMARK;
5047 uint benchmark_mode = BENCHMARK_MODE;
5048 uint show = SHOW;
5049 uint left = LEFT;
5050 uint username = USERNAME;
5051 uint remove = REMOVE;
5052 uint remove_timer = REMOVE_TIMER;
5053 uint64_t skip = SKIP;
5054 uint64_t limit = LIMIT;
5055 uint keyspace = KEYSPACE;
5056 uint potfile_disable = POTFILE_DISABLE;
5057 uint debug_mode = DEBUG_MODE;
5058 char *debug_file = NULL;
5059 char *induction_dir = NULL;
5060 char *outfile_check_dir = NULL;
5061 uint force = FORCE;
5062 uint runtime = RUNTIME;
5063 uint hash_mode = HASH_MODE;
5064 uint attack_mode = ATTACK_MODE;
5065 uint markov_disable = MARKOV_DISABLE;
5066 uint markov_classic = MARKOV_CLASSIC;
5067 uint markov_threshold = MARKOV_THRESHOLD;
5068 char *markov_hcstat = NULL;
5069 char *outfile = NULL;
5070 uint outfile_format = OUTFILE_FORMAT;
5071 uint outfile_autohex = OUTFILE_AUTOHEX;
5072 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5073 uint restore = RESTORE;
5074 uint restore_timer = RESTORE_TIMER;
5075 uint restore_disable = RESTORE_DISABLE;
5076 uint status = STATUS;
5077 uint status_timer = STATUS_TIMER;
5078 uint status_automat = STATUS_AUTOMAT;
5079 uint loopback = LOOPBACK;
5080 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5081 char *session = NULL;
5082 uint hex_charset = HEX_CHARSET;
5083 uint hex_salt = HEX_SALT;
5084 uint hex_wordlist = HEX_WORDLIST;
5085 uint rp_gen = RP_GEN;
5086 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5087 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5088 uint rp_gen_seed = RP_GEN_SEED;
5089 char *rule_buf_l = (char *) RULE_BUF_L;
5090 char *rule_buf_r = (char *) RULE_BUF_R;
5091 uint increment = INCREMENT;
5092 uint increment_min = INCREMENT_MIN;
5093 uint increment_max = INCREMENT_MAX;
5094 char *cpu_affinity = NULL;
5095 char *opencl_devices = NULL;
5096 char *opencl_platforms = NULL;
5097 char *opencl_device_types = NULL;
5098 char *truecrypt_keyfiles = NULL;
5099 uint workload_profile = WORKLOAD_PROFILE;
5100 uint kernel_accel = KERNEL_ACCEL;
5101 uint kernel_loops = KERNEL_LOOPS;
5102 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5103 uint gpu_temp_abort = GPU_TEMP_ABORT;
5104 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5105 uint powertune_enable = POWERTUNE_ENABLE;
5106 uint logfile_disable = LOGFILE_DISABLE;
5107 uint segment_size = SEGMENT_SIZE;
5108 uint scrypt_tmto = SCRYPT_TMTO;
5109 char separator = SEPARATOR;
5110 uint bitmap_min = BITMAP_MIN;
5111 uint bitmap_max = BITMAP_MAX;
5112 char *custom_charset_1 = NULL;
5113 char *custom_charset_2 = NULL;
5114 char *custom_charset_3 = NULL;
5115 char *custom_charset_4 = NULL;
5116
5117 #define IDX_HELP 'h'
5118 #define IDX_VERSION 'V'
5119 #define IDX_VERSION_LOWER 'v'
5120 #define IDX_QUIET 0xff02
5121 #define IDX_SHOW 0xff03
5122 #define IDX_LEFT 0xff04
5123 #define IDX_REMOVE 0xff05
5124 #define IDX_REMOVE_TIMER 0xff37
5125 #define IDX_SKIP 's'
5126 #define IDX_LIMIT 'l'
5127 #define IDX_KEYSPACE 0xff35
5128 #define IDX_POTFILE_DISABLE 0xff06
5129 #define IDX_DEBUG_MODE 0xff43
5130 #define IDX_DEBUG_FILE 0xff44
5131 #define IDX_INDUCTION_DIR 0xff46
5132 #define IDX_OUTFILE_CHECK_DIR 0xff47
5133 #define IDX_USERNAME 0xff07
5134 #define IDX_FORCE 0xff08
5135 #define IDX_RUNTIME 0xff09
5136 #define IDX_BENCHMARK 'b'
5137 #define IDX_BENCHMARK_MODE 0xff32
5138 #define IDX_HASH_MODE 'm'
5139 #define IDX_ATTACK_MODE 'a'
5140 #define IDX_RP_FILE 'r'
5141 #define IDX_RP_GEN 'g'
5142 #define IDX_RP_GEN_FUNC_MIN 0xff10
5143 #define IDX_RP_GEN_FUNC_MAX 0xff11
5144 #define IDX_RP_GEN_SEED 0xff34
5145 #define IDX_RULE_BUF_L 'j'
5146 #define IDX_RULE_BUF_R 'k'
5147 #define IDX_INCREMENT 'i'
5148 #define IDX_INCREMENT_MIN 0xff12
5149 #define IDX_INCREMENT_MAX 0xff13
5150 #define IDX_OUTFILE 'o'
5151 #define IDX_OUTFILE_FORMAT 0xff14
5152 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5153 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5154 #define IDX_RESTORE 0xff15
5155 #define IDX_RESTORE_DISABLE 0xff27
5156 #define IDX_STATUS 0xff17
5157 #define IDX_STATUS_TIMER 0xff18
5158 #define IDX_STATUS_AUTOMAT 0xff50
5159 #define IDX_LOOPBACK 0xff38
5160 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5161 #define IDX_SESSION 0xff19
5162 #define IDX_HEX_CHARSET 0xff20
5163 #define IDX_HEX_SALT 0xff21
5164 #define IDX_HEX_WORDLIST 0xff40
5165 #define IDX_MARKOV_DISABLE 0xff22
5166 #define IDX_MARKOV_CLASSIC 0xff23
5167 #define IDX_MARKOV_THRESHOLD 't'
5168 #define IDX_MARKOV_HCSTAT 0xff24
5169 #define IDX_CPU_AFFINITY 0xff25
5170 #define IDX_OPENCL_DEVICES 'd'
5171 #define IDX_OPENCL_PLATFORMS 0xff72
5172 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5173 #define IDX_WORKLOAD_PROFILE 'w'
5174 #define IDX_KERNEL_ACCEL 'n'
5175 #define IDX_KERNEL_LOOPS 'u'
5176 #define IDX_GPU_TEMP_DISABLE 0xff29
5177 #define IDX_GPU_TEMP_ABORT 0xff30
5178 #define IDX_GPU_TEMP_RETAIN 0xff31
5179 #define IDX_POWERTUNE_ENABLE 0xff41
5180 #define IDX_LOGFILE_DISABLE 0xff51
5181 #define IDX_TRUECRYPT_KEYFILES 0xff52
5182 #define IDX_SCRYPT_TMTO 0xff61
5183 #define IDX_SEGMENT_SIZE 'c'
5184 #define IDX_SEPARATOR 'p'
5185 #define IDX_BITMAP_MIN 0xff70
5186 #define IDX_BITMAP_MAX 0xff71
5187 #define IDX_CUSTOM_CHARSET_1 '1'
5188 #define IDX_CUSTOM_CHARSET_2 '2'
5189 #define IDX_CUSTOM_CHARSET_3 '3'
5190 #define IDX_CUSTOM_CHARSET_4 '4'
5191
5192 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5193
5194 struct option long_options[] =
5195 {
5196 {"help", no_argument, 0, IDX_HELP},
5197 {"version", no_argument, 0, IDX_VERSION},
5198 {"quiet", no_argument, 0, IDX_QUIET},
5199 {"show", no_argument, 0, IDX_SHOW},
5200 {"left", no_argument, 0, IDX_LEFT},
5201 {"username", no_argument, 0, IDX_USERNAME},
5202 {"remove", no_argument, 0, IDX_REMOVE},
5203 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5204 {"skip", required_argument, 0, IDX_SKIP},
5205 {"limit", required_argument, 0, IDX_LIMIT},
5206 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5207 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5208 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5209 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5210 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5211 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5212 {"force", no_argument, 0, IDX_FORCE},
5213 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5214 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5215 {"restore", no_argument, 0, IDX_RESTORE},
5216 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5217 {"status", no_argument, 0, IDX_STATUS},
5218 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5219 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5220 {"loopback", no_argument, 0, IDX_LOOPBACK},
5221 {"weak-hash-threshold",
5222 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5223 {"session", required_argument, 0, IDX_SESSION},
5224 {"runtime", required_argument, 0, IDX_RUNTIME},
5225 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5226 {"generate-rules-func-min",
5227 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5228 {"generate-rules-func-max",
5229 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5230 {"generate-rules-seed",
5231 required_argument, 0, IDX_RP_GEN_SEED},
5232 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5233 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5234 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5235 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5236 {"rules-file", required_argument, 0, IDX_RP_FILE},
5237 {"outfile", required_argument, 0, IDX_OUTFILE},
5238 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5239 {"outfile-autohex-disable",
5240 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5241 {"outfile-check-timer",
5242 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5243 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5244 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5245 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5246 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5247 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5248 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5249 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5250 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5251 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5252 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5253 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5254 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5255 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5256 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5257 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5258 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5259 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5260 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5261 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5262 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5263 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5264 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5265 // deprecated
5266 {"seperator", required_argument, 0, IDX_SEPARATOR},
5267 {"separator", required_argument, 0, IDX_SEPARATOR},
5268 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5269 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5270 {"increment", no_argument, 0, IDX_INCREMENT},
5271 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5272 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5273 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5274 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5275 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5276 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5277
5278 {0, 0, 0, 0}
5279 };
5280
5281 uint rp_files_cnt = 0;
5282
5283 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5284
5285 int option_index;
5286 int c;
5287
5288 optind = 1;
5289 optopt = 0;
5290 option_index = 0;
5291
5292 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5293 {
5294 switch (c)
5295 {
5296 case IDX_HELP: usage = 1; break;
5297 case IDX_VERSION:
5298 case IDX_VERSION_LOWER: version = 1; break;
5299 case IDX_RESTORE: restore = 1; break;
5300 case IDX_SESSION: session = optarg; break;
5301 case IDX_SHOW: show = 1; break;
5302 case IDX_LEFT: left = 1; break;
5303 case '?': return (-1);
5304 }
5305 }
5306
5307 if (optopt != 0)
5308 {
5309 log_error ("ERROR: Invalid argument specified");
5310
5311 return (-1);
5312 }
5313
5314 /**
5315 * exit functions
5316 */
5317
5318 if (version)
5319 {
5320 log_info (VERSION_TXT);
5321
5322 return (0);
5323 }
5324
5325 if (usage)
5326 {
5327 usage_big_print (PROGNAME);
5328
5329 return (0);
5330 }
5331
5332 /**
5333 * session needs to be set, always!
5334 */
5335
5336 if (session == NULL) session = (char *) PROGNAME;
5337
5338 /**
5339 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5340 */
5341
5342 char *exec_path = get_exec_path ();
5343
5344 #ifdef LINUX
5345
5346 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5347 char *resolved_exec_path = realpath (exec_path, NULL);
5348
5349 char *install_dir = get_install_dir (resolved_exec_path);
5350 char *profile_dir = NULL;
5351 char *session_dir = NULL;
5352 char *shared_dir = NULL;
5353
5354 if (strcmp (install_dir, resolved_install_folder) == 0)
5355 {
5356 struct passwd *pw = getpwuid (getuid ());
5357
5358 const char *homedir = pw->pw_dir;
5359
5360 profile_dir = get_profile_dir (homedir);
5361 session_dir = get_session_dir (profile_dir);
5362 shared_dir = strdup (SHARED_FOLDER);
5363
5364 mkdir (profile_dir, 0700);
5365 mkdir (session_dir, 0700);
5366 }
5367 else
5368 {
5369 profile_dir = install_dir;
5370 session_dir = install_dir;
5371 shared_dir = install_dir;
5372 }
5373
5374 myfree (resolved_install_folder);
5375 myfree (resolved_exec_path);
5376
5377 #else
5378
5379 char *install_dir = get_install_dir (exec_path);
5380 char *profile_dir = install_dir;
5381 char *session_dir = install_dir;
5382 char *shared_dir = install_dir;
5383
5384 #endif
5385
5386 data.install_dir = install_dir;
5387 data.profile_dir = profile_dir;
5388 data.session_dir = session_dir;
5389 data.shared_dir = shared_dir;
5390
5391 myfree (exec_path);
5392
5393 /**
5394 * kernel cache, we need to make sure folder exist
5395 */
5396
5397 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5398
5399 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5400
5401 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5402
5403 mkdir (kernels_folder, 0700);
5404
5405 myfree (kernels_folder);
5406
5407 /**
5408 * session
5409 */
5410
5411 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5412
5413 data.session = session;
5414
5415 char *eff_restore_file = (char *) mymalloc (session_size);
5416 char *new_restore_file = (char *) mymalloc (session_size);
5417
5418 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5419 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5420
5421 data.eff_restore_file = eff_restore_file;
5422 data.new_restore_file = new_restore_file;
5423
5424 if (((show == 1) || (left == 1)) && (restore == 1))
5425 {
5426 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5427 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5428
5429 return (-1);
5430 }
5431
5432 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5433 if ((show == 1) || (left == 1))
5434 {
5435 restore_disable = 1;
5436
5437 restore = 0;
5438 }
5439
5440 data.restore_disable = restore_disable;
5441
5442 restore_data_t *rd = init_restore (argc, argv);
5443
5444 data.rd = rd;
5445
5446 /**
5447 * restore file
5448 */
5449
5450 if (restore == 1)
5451 {
5452 read_restore (eff_restore_file, rd);
5453
5454 if (rd->version_bin < RESTORE_MIN)
5455 {
5456 log_error ("ERROR: Incompatible restore-file version");
5457
5458 return (-1);
5459 }
5460
5461 myargc = rd->argc;
5462 myargv = rd->argv;
5463
5464 #ifdef _POSIX
5465 rd->pid = getpid ();
5466 #elif _WIN
5467 rd->pid = GetCurrentProcessId ();
5468 #endif
5469 }
5470
5471 uint hash_mode_chgd = 0;
5472 uint runtime_chgd = 0;
5473 uint kernel_loops_chgd = 0;
5474 uint kernel_accel_chgd = 0;
5475 uint attack_mode_chgd = 0;
5476 uint outfile_format_chgd = 0;
5477 uint rp_gen_seed_chgd = 0;
5478 uint remove_timer_chgd = 0;
5479 uint increment_min_chgd = 0;
5480 uint increment_max_chgd = 0;
5481 uint gpu_temp_abort_chgd = 0;
5482 uint gpu_temp_retain_chgd = 0;
5483
5484 optind = 1;
5485 optopt = 0;
5486 option_index = 0;
5487
5488 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5489 {
5490 switch (c)
5491 {
5492 //case IDX_HELP: usage = 1; break;
5493 //case IDX_VERSION: version = 1; break;
5494 //case IDX_RESTORE: restore = 1; break;
5495 case IDX_QUIET: quiet = 1; break;
5496 //case IDX_SHOW: show = 1; break;
5497 case IDX_SHOW: break;
5498 //case IDX_LEFT: left = 1; break;
5499 case IDX_LEFT: break;
5500 case IDX_USERNAME: username = 1; break;
5501 case IDX_REMOVE: remove = 1; break;
5502 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5503 remove_timer_chgd = 1; break;
5504 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5505 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5506 case IDX_DEBUG_FILE: debug_file = optarg; break;
5507 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5508 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5509 case IDX_FORCE: force = 1; break;
5510 case IDX_SKIP: skip = atoll (optarg); break;
5511 case IDX_LIMIT: limit = atoll (optarg); break;
5512 case IDX_KEYSPACE: keyspace = 1; break;
5513 case IDX_BENCHMARK: benchmark = 1; break;
5514 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5515 case IDX_RESTORE: break;
5516 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5517 case IDX_STATUS: status = 1; break;
5518 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5519 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5520 case IDX_LOOPBACK: loopback = 1; break;
5521 case IDX_WEAK_HASH_THRESHOLD:
5522 weak_hash_threshold = atoi (optarg); break;
5523 //case IDX_SESSION: session = optarg; break;
5524 case IDX_SESSION: break;
5525 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5526 hash_mode_chgd = 1; break;
5527 case IDX_RUNTIME: runtime = atoi (optarg);
5528 runtime_chgd = 1; break;
5529 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5530 attack_mode_chgd = 1; break;
5531 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5532 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5533 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5534 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5535 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5536 rp_gen_seed_chgd = 1; break;
5537 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5538 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5539 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5540 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5541 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5542 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5543 case IDX_OUTFILE: outfile = optarg; break;
5544 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5545 outfile_format_chgd = 1; break;
5546 case IDX_OUTFILE_AUTOHEX_DISABLE:
5547 outfile_autohex = 0; break;
5548 case IDX_OUTFILE_CHECK_TIMER:
5549 outfile_check_timer = atoi (optarg); break;
5550 case IDX_HEX_CHARSET: hex_charset = 1; break;
5551 case IDX_HEX_SALT: hex_salt = 1; break;
5552 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5553 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5554 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5555 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5556 case IDX_OPENCL_DEVICE_TYPES:
5557 opencl_device_types = optarg; break;
5558 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5559 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5560 kernel_accel_chgd = 1; break;
5561 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5562 kernel_loops_chgd = 1; break;
5563 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5564 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5565 gpu_temp_abort = atoi (optarg); break;
5566 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5567 gpu_temp_retain = atoi (optarg); break;
5568 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5569 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5570 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5571 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5572 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5573 case IDX_SEPARATOR: separator = optarg[0]; break;
5574 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5575 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5576 case IDX_INCREMENT: increment = 1; break;
5577 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5578 increment_min_chgd = 1; break;
5579 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5580 increment_max_chgd = 1; break;
5581 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5582 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5583 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5584 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5585
5586 default:
5587 log_error ("ERROR: Invalid argument specified");
5588 return (-1);
5589 }
5590 }
5591
5592 if (optopt != 0)
5593 {
5594 log_error ("ERROR: Invalid argument specified");
5595
5596 return (-1);
5597 }
5598
5599 /**
5600 * Inform user things getting started,
5601 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5602 * - we do not need to check algorithm_pos
5603 */
5604
5605 if (quiet == 0)
5606 {
5607 if (benchmark == 1)
5608 {
5609 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5610
5611 log_info ("");
5612 }
5613 else if (restore == 1)
5614 {
5615 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5616
5617 log_info ("");
5618 }
5619 else
5620 {
5621 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5622
5623 log_info ("");
5624 }
5625 }
5626
5627 /**
5628 * sanity check
5629 */
5630
5631 if (attack_mode > 7)
5632 {
5633 log_error ("ERROR: Invalid attack-mode specified");
5634
5635 return (-1);
5636 }
5637
5638 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5639 {
5640 log_error ("ERROR: Invalid runtime specified");
5641
5642 return (-1);
5643 }
5644
5645 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5646 {
5647 log_error ("ERROR: Invalid hash-type specified");
5648
5649 return (-1);
5650 }
5651
5652 // renamed hash modes
5653
5654 if (hash_mode_chgd)
5655 {
5656 int n = -1;
5657
5658 switch (hash_mode)
5659 {
5660 case 123: n = 124;
5661 break;
5662 }
5663
5664 if (n >= 0)
5665 {
5666 log_error ("Old -m specified, use -m %d instead", n);
5667
5668 return (-1);
5669 }
5670 }
5671
5672 if (username == 1)
5673 {
5674 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5675 {
5676 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5677
5678 return (-1);
5679 }
5680 }
5681
5682 if (outfile_format > 16)
5683 {
5684 log_error ("ERROR: Invalid outfile-format specified");
5685
5686 return (-1);
5687 }
5688
5689 if (left == 1)
5690 {
5691 if (outfile_format_chgd == 1)
5692 {
5693 if (outfile_format > 1)
5694 {
5695 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5696
5697 return (-1);
5698 }
5699 }
5700 else
5701 {
5702 outfile_format = OUTFILE_FMT_HASH;
5703 }
5704 }
5705
5706 if (show == 1)
5707 {
5708 if (outfile_format_chgd == 1)
5709 {
5710 if ((outfile_format > 7) && (outfile_format < 16))
5711 {
5712 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5713
5714 return (-1);
5715 }
5716 }
5717 }
5718
5719 if (increment_min < INCREMENT_MIN)
5720 {
5721 log_error ("ERROR: Invalid increment-min specified");
5722
5723 return (-1);
5724 }
5725
5726 if (increment_max > INCREMENT_MAX)
5727 {
5728 log_error ("ERROR: Invalid increment-max specified");
5729
5730 return (-1);
5731 }
5732
5733 if (increment_min > increment_max)
5734 {
5735 log_error ("ERROR: Invalid increment-min specified");
5736
5737 return (-1);
5738 }
5739
5740 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5741 {
5742 log_error ("ERROR: increment is not allowed in attack-mode 0");
5743
5744 return (-1);
5745 }
5746
5747 if ((increment == 0) && (increment_min_chgd == 1))
5748 {
5749 log_error ("ERROR: increment-min is only supported together with increment switch");
5750
5751 return (-1);
5752 }
5753
5754 if ((increment == 0) && (increment_max_chgd == 1))
5755 {
5756 log_error ("ERROR: increment-max is only supported together with increment switch");
5757
5758 return (-1);
5759 }
5760
5761 if (rp_files_cnt && rp_gen)
5762 {
5763 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5764
5765 return (-1);
5766 }
5767
5768 if (rp_files_cnt || rp_gen)
5769 {
5770 if (attack_mode != ATTACK_MODE_STRAIGHT)
5771 {
5772 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5773
5774 return (-1);
5775 }
5776 }
5777
5778 if (rp_gen_func_min > rp_gen_func_max)
5779 {
5780 log_error ("ERROR: Invalid rp-gen-func-min specified");
5781
5782 return (-1);
5783 }
5784
5785 if (kernel_accel_chgd == 1)
5786 {
5787 if (workload_profile != WORKLOAD_PROFILE)
5788 {
5789 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5790
5791 return (-1);
5792 }
5793
5794 if (kernel_accel < 1)
5795 {
5796 log_error ("ERROR: Invalid kernel-accel specified");
5797
5798 return (-1);
5799 }
5800
5801 if (kernel_accel > 800)
5802 {
5803 log_error ("ERROR: Invalid kernel-accel specified");
5804
5805 return (-1);
5806 }
5807 }
5808
5809 if (kernel_loops_chgd == 1)
5810 {
5811 if (workload_profile != WORKLOAD_PROFILE)
5812 {
5813 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5814
5815 return (-1);
5816 }
5817
5818 if (kernel_loops < 1)
5819 {
5820 log_error ("ERROR: Invalid kernel-loops specified");
5821
5822 return (-1);
5823 }
5824
5825 if (kernel_loops > 1024)
5826 {
5827 log_error ("ERROR: Invalid kernel-loops specified");
5828
5829 return (-1);
5830 }
5831 }
5832
5833 if (benchmark == 1)
5834 {
5835 if (workload_profile != WORKLOAD_PROFILE)
5836 {
5837 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5838
5839 return (-1);
5840 }
5841 }
5842
5843 if ((workload_profile < 1) || (workload_profile > 3))
5844 {
5845 log_error ("ERROR: workload-profile %i not available", workload_profile);
5846
5847 return (-1);
5848 }
5849
5850 if (show == 1 || left == 1)
5851 {
5852 attack_mode = ATTACK_MODE_NONE;
5853
5854 if (remove == 1)
5855 {
5856 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5857
5858 return (-1);
5859 }
5860
5861 if (potfile_disable == 1)
5862 {
5863 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5864
5865 return (-1);
5866 }
5867 }
5868
5869 uint attack_kern = ATTACK_KERN_NONE;
5870
5871 switch (attack_mode)
5872 {
5873 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5874 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5875 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5876 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5877 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5878 }
5879
5880 if (benchmark == 0)
5881 {
5882 if (keyspace == 1)
5883 {
5884 int num_additional_params = 1;
5885
5886 if (attack_kern == ATTACK_KERN_COMBI)
5887 {
5888 num_additional_params = 2;
5889 }
5890
5891 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5892
5893 if (keyspace_wordlist_specified == 0) optind--;
5894 }
5895
5896 if (attack_kern == ATTACK_KERN_NONE)
5897 {
5898 if ((optind + 1) != myargc)
5899 {
5900 usage_mini_print (myargv[0]);
5901
5902 return (-1);
5903 }
5904 }
5905 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5906 {
5907 if ((optind + 1) > myargc)
5908 {
5909 usage_mini_print (myargv[0]);
5910
5911 return (-1);
5912 }
5913 }
5914 else if (attack_kern == ATTACK_KERN_COMBI)
5915 {
5916 if ((optind + 3) != myargc)
5917 {
5918 usage_mini_print (myargv[0]);
5919
5920 return (-1);
5921 }
5922 }
5923 else if (attack_kern == ATTACK_KERN_BF)
5924 {
5925 if ((optind + 1) > myargc)
5926 {
5927 usage_mini_print (myargv[0]);
5928
5929 return (-1);
5930 }
5931 }
5932 else
5933 {
5934 usage_mini_print (myargv[0]);
5935
5936 return (-1);
5937 }
5938 }
5939 else
5940 {
5941 if (myargv[optind] != 0)
5942 {
5943 log_error ("ERROR: Invalid argument for benchmark mode specified");
5944
5945 return (-1);
5946 }
5947
5948 if (attack_mode_chgd == 1)
5949 {
5950 if (attack_mode != ATTACK_MODE_BF)
5951 {
5952 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5953
5954 return (-1);
5955 }
5956 }
5957
5958 if (benchmark_mode == 0)
5959 {
5960 // nothing to do
5961 }
5962 else if (benchmark_mode == 1)
5963 {
5964 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
5965 {
5966 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
5967
5968 return (-1);
5969 }
5970 }
5971 else
5972 {
5973 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5974
5975 return (-1);
5976 }
5977 }
5978
5979 if (skip != 0 && limit != 0)
5980 {
5981 limit += skip;
5982 }
5983
5984 if (keyspace == 1)
5985 {
5986 if (show == 1)
5987 {
5988 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
5989
5990 return (-1);
5991 }
5992 else if (left == 1)
5993 {
5994 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
5995
5996 return (-1);
5997 }
5998
5999 potfile_disable = 1;
6000
6001 restore_disable = 1;
6002
6003 restore = 0;
6004
6005 weak_hash_threshold = 0;
6006
6007 quiet = 1;
6008 }
6009
6010 if (remove_timer_chgd == 1)
6011 {
6012 if (remove == 0)
6013 {
6014 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6015
6016 return (-1);
6017 }
6018
6019 if (remove_timer < 1)
6020 {
6021 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6022
6023 return (-1);
6024 }
6025 }
6026
6027 if (loopback == 1)
6028 {
6029 if (attack_mode == ATTACK_MODE_BF)
6030 {
6031 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6032
6033 return (-1);
6034 }
6035 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6036 {
6037 if ((rp_files_cnt == 0) && (rp_gen == 0))
6038 {
6039 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6040
6041 return (-1);
6042 }
6043 }
6044 }
6045
6046 if (debug_mode > 0)
6047 {
6048 if (attack_mode != ATTACK_MODE_STRAIGHT)
6049 {
6050 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6051
6052 return (-1);
6053 }
6054
6055 if ((rp_files_cnt == 0) && (rp_gen == 0))
6056 {
6057 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6058
6059 return (-1);
6060 }
6061 }
6062
6063 if (debug_mode > 4)
6064 {
6065 log_error ("ERROR: Invalid debug-mode specified");
6066
6067 return (-1);
6068 }
6069
6070 if (debug_file != NULL)
6071 {
6072 if (debug_mode < 1)
6073 {
6074 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6075
6076 return (-1);
6077 }
6078 }
6079
6080 if (induction_dir != NULL)
6081 {
6082 if (attack_mode == ATTACK_MODE_BF)
6083 {
6084 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6085
6086 return (-1);
6087 }
6088 }
6089
6090 if (attack_mode != ATTACK_MODE_STRAIGHT)
6091 {
6092 if (weak_hash_threshold != WEAK_HASH_THRESHOLD)
6093 {
6094 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6095
6096 return (-1);
6097 }
6098
6099 weak_hash_threshold = 0;
6100 }
6101
6102 /**
6103 * induction directory
6104 */
6105
6106 char *induction_directory = NULL;
6107
6108 if (attack_mode != ATTACK_MODE_BF)
6109 {
6110 if (induction_dir == NULL)
6111 {
6112 induction_directory = (char *) mymalloc (session_size);
6113
6114 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6115
6116 // create induction folder if it does not already exist
6117
6118 if (keyspace == 0)
6119 {
6120 if (rmdir (induction_directory) == -1)
6121 {
6122 if (errno == ENOENT)
6123 {
6124 // good, we can ignore
6125 }
6126 else if (errno == ENOTEMPTY)
6127 {
6128 char *induction_directory_mv = (char *) mymalloc (session_size);
6129
6130 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6131
6132 if (rename (induction_directory, induction_directory_mv) != 0)
6133 {
6134 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6135
6136 return (-1);
6137 }
6138 }
6139 else
6140 {
6141 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6142
6143 return (-1);
6144 }
6145 }
6146
6147 if (mkdir (induction_directory, 0700) == -1)
6148 {
6149 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6150
6151 return (-1);
6152 }
6153 }
6154 }
6155 else
6156 {
6157 induction_directory = induction_dir;
6158 }
6159 }
6160
6161 data.induction_directory = induction_directory;
6162
6163 /**
6164 * loopback
6165 */
6166
6167 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6168
6169 char *loopback_file = (char *) mymalloc (loopback_size);
6170
6171 /**
6172 * outfile-check directory
6173 */
6174
6175 char *outfile_check_directory = NULL;
6176
6177 if (outfile_check_dir == NULL)
6178 {
6179 outfile_check_directory = (char *) mymalloc (session_size);
6180
6181 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6182 }
6183 else
6184 {
6185 outfile_check_directory = outfile_check_dir;
6186 }
6187
6188 data.outfile_check_directory = outfile_check_directory;
6189
6190 if (keyspace == 0)
6191 {
6192 struct stat outfile_check_stat;
6193
6194 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6195 {
6196 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6197
6198 if (is_dir == 0)
6199 {
6200 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6201
6202 return (-1);
6203 }
6204 }
6205 else if (outfile_check_dir == NULL)
6206 {
6207 if (mkdir (outfile_check_directory, 0700) == -1)
6208 {
6209 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6210
6211 return (-1);
6212 }
6213 }
6214 }
6215
6216 /**
6217 * special other stuff
6218 */
6219
6220 if (hash_mode == 9710)
6221 {
6222 outfile_format = 5;
6223 outfile_format_chgd = 1;
6224 }
6225
6226 if (hash_mode == 9810)
6227 {
6228 outfile_format = 5;
6229 outfile_format_chgd = 1;
6230 }
6231
6232 if (hash_mode == 10410)
6233 {
6234 outfile_format = 5;
6235 outfile_format_chgd = 1;
6236 }
6237
6238 /**
6239 * store stuff
6240 */
6241
6242 data.hash_mode = hash_mode;
6243 data.restore = restore;
6244 data.restore_timer = restore_timer;
6245 data.restore_disable = restore_disable;
6246 data.status = status;
6247 data.status_timer = status_timer;
6248 data.status_automat = status_automat;
6249 data.loopback = loopback;
6250 data.runtime = runtime;
6251 data.remove = remove;
6252 data.remove_timer = remove_timer;
6253 data.debug_mode = debug_mode;
6254 data.debug_file = debug_file;
6255 data.username = username;
6256 data.quiet = quiet;
6257 data.outfile = outfile;
6258 data.outfile_format = outfile_format;
6259 data.outfile_autohex = outfile_autohex;
6260 data.hex_charset = hex_charset;
6261 data.hex_salt = hex_salt;
6262 data.hex_wordlist = hex_wordlist;
6263 data.separator = separator;
6264 data.rp_files = rp_files;
6265 data.rp_files_cnt = rp_files_cnt;
6266 data.rp_gen = rp_gen;
6267 data.rp_gen_seed = rp_gen_seed;
6268 data.force = force;
6269 data.benchmark = benchmark;
6270 data.skip = skip;
6271 data.limit = limit;
6272 data.powertune_enable = powertune_enable;
6273 data.logfile_disable = logfile_disable;
6274 data.truecrypt_keyfiles = truecrypt_keyfiles;
6275 data.scrypt_tmto = scrypt_tmto;
6276
6277 /**
6278 * cpu affinity
6279 */
6280
6281 if (cpu_affinity)
6282 {
6283 set_cpu_affinity (cpu_affinity);
6284 }
6285
6286 if (rp_gen_seed_chgd == 0)
6287 {
6288 srand (proc_start);
6289 }
6290 else
6291 {
6292 srand (rp_gen_seed);
6293 }
6294
6295 /**
6296 * logfile init
6297 */
6298
6299 if (logfile_disable == 0)
6300 {
6301 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6302
6303 char *logfile = (char *) mymalloc (logfile_size);
6304
6305 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6306
6307 data.logfile = logfile;
6308
6309 char *topid = logfile_generate_topid ();
6310
6311 data.topid = topid;
6312 }
6313
6314 // logfile_append() checks for logfile_disable internally to make it easier from here
6315
6316 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6317 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6318 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6319 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6320 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6321 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6322 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6323 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6324 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6325 #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));
6326
6327 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6328 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6329 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6330 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6331 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6332 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6333 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6334 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6335
6336 logfile_top_msg ("START");
6337
6338 logfile_top_uint (attack_mode);
6339 logfile_top_uint (attack_kern);
6340 logfile_top_uint (benchmark);
6341 logfile_top_uint (benchmark_mode);
6342 logfile_top_uint (bitmap_min);
6343 logfile_top_uint (bitmap_max);
6344 logfile_top_uint (debug_mode);
6345 logfile_top_uint (force);
6346 logfile_top_uint (kernel_accel);
6347 logfile_top_uint (kernel_loops);
6348 logfile_top_uint (gpu_temp_abort);
6349 logfile_top_uint (gpu_temp_disable);
6350 logfile_top_uint (gpu_temp_retain);
6351 logfile_top_uint (hash_mode);
6352 logfile_top_uint (hex_charset);
6353 logfile_top_uint (hex_salt);
6354 logfile_top_uint (hex_wordlist);
6355 logfile_top_uint (increment);
6356 logfile_top_uint (increment_max);
6357 logfile_top_uint (increment_min);
6358 logfile_top_uint (keyspace);
6359 logfile_top_uint (left);
6360 logfile_top_uint (logfile_disable);
6361 logfile_top_uint (loopback);
6362 logfile_top_uint (markov_classic);
6363 logfile_top_uint (markov_disable);
6364 logfile_top_uint (markov_threshold);
6365 logfile_top_uint (outfile_autohex);
6366 logfile_top_uint (outfile_check_timer);
6367 logfile_top_uint (outfile_format);
6368 logfile_top_uint (potfile_disable);
6369 logfile_top_uint (powertune_enable);
6370 logfile_top_uint (scrypt_tmto);
6371 logfile_top_uint (quiet);
6372 logfile_top_uint (remove);
6373 logfile_top_uint (remove_timer);
6374 logfile_top_uint (restore);
6375 logfile_top_uint (restore_disable);
6376 logfile_top_uint (restore_timer);
6377 logfile_top_uint (rp_gen);
6378 logfile_top_uint (rp_gen_func_max);
6379 logfile_top_uint (rp_gen_func_min);
6380 logfile_top_uint (rp_gen_seed);
6381 logfile_top_uint (runtime);
6382 logfile_top_uint (segment_size);
6383 logfile_top_uint (show);
6384 logfile_top_uint (status);
6385 logfile_top_uint (status_automat);
6386 logfile_top_uint (status_timer);
6387 logfile_top_uint (usage);
6388 logfile_top_uint (username);
6389 logfile_top_uint (version);
6390 logfile_top_uint (weak_hash_threshold);
6391 logfile_top_uint (workload_profile);
6392 logfile_top_uint64 (limit);
6393 logfile_top_uint64 (skip);
6394 logfile_top_char (separator);
6395 logfile_top_string (cpu_affinity);
6396 logfile_top_string (custom_charset_1);
6397 logfile_top_string (custom_charset_2);
6398 logfile_top_string (custom_charset_3);
6399 logfile_top_string (custom_charset_4);
6400 logfile_top_string (debug_file);
6401 logfile_top_string (opencl_devices);
6402 logfile_top_string (opencl_platforms);
6403 logfile_top_string (opencl_device_types);
6404 logfile_top_string (induction_dir);
6405 logfile_top_string (markov_hcstat);
6406 logfile_top_string (outfile);
6407 logfile_top_string (outfile_check_dir);
6408 logfile_top_string (rule_buf_l);
6409 logfile_top_string (rule_buf_r);
6410 logfile_top_string (session);
6411 logfile_top_string (truecrypt_keyfiles);
6412
6413 /**
6414 * OpenCL platform selection
6415 */
6416
6417 uint opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6418
6419 /**
6420 * OpenCL device selection
6421 */
6422
6423 uint opencl_devicemask = devices_to_devicemask (opencl_devices);
6424
6425 /**
6426 * OpenCL device type selection
6427 */
6428
6429 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6430
6431 /**
6432 * benchmark
6433 */
6434
6435 if (benchmark == 1)
6436 {
6437 /**
6438 * disable useless stuff for benchmark
6439 */
6440
6441 restore_timer = 0;
6442 status_timer = 0;
6443 restore_disable = 1;
6444 potfile_disable = 1;
6445 weak_hash_threshold = 0;
6446
6447 data.restore_timer = restore_timer;
6448 data.status_timer = status_timer;
6449 data.restore_disable = restore_disable;
6450
6451 if (benchmark_mode == 1)
6452 {
6453 markov_disable = 1;
6454 }
6455
6456 /**
6457 * force attack mode to be bruteforce
6458 */
6459
6460 attack_mode = ATTACK_MODE_BF;
6461 attack_kern = ATTACK_KERN_BF;
6462
6463 if (runtime_chgd == 0)
6464 {
6465 runtime = 4;
6466
6467 if (benchmark_mode == 1) runtime = 17;
6468
6469 data.runtime = runtime;
6470 }
6471 }
6472
6473 /**
6474 * config
6475 */
6476
6477 uint hash_type = 0;
6478 uint salt_type = 0;
6479 uint attack_exec = 0;
6480 uint opts_type = 0;
6481 uint kern_type = 0;
6482 uint dgst_size = 0;
6483 uint esalt_size = 0;
6484 uint opti_type = 0;
6485 uint dgst_pos0 = -1;
6486 uint dgst_pos1 = -1;
6487 uint dgst_pos2 = -1;
6488 uint dgst_pos3 = -1;
6489
6490 int (*parse_func) (char *, uint, hash_t *);
6491 int (*sort_by_digest) (const void *, const void *);
6492
6493 uint algorithm_pos = 0;
6494 uint algorithm_max = 1;
6495
6496 uint *algorithms = default_benchmark_algorithms;
6497
6498 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6499
6500 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6501 {
6502 /*
6503 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6504 * the following algos are skipped entirely
6505 */
6506
6507 if (algorithm_pos > 0)
6508 {
6509 local_free (rd);
6510
6511 rd = init_restore (argc, argv);
6512
6513 data.rd = rd;
6514 }
6515
6516 /**
6517 * update hash_mode in case of multihash benchmark
6518 */
6519
6520 if (benchmark == 1)
6521 {
6522 if (hash_mode_chgd == 0)
6523 {
6524 hash_mode = algorithms[algorithm_pos];
6525
6526 data.hash_mode = hash_mode;
6527 }
6528
6529 quiet = 1;
6530
6531 data.quiet = quiet;
6532 }
6533
6534 switch (hash_mode)
6535 {
6536 case 0: hash_type = HASH_TYPE_MD5;
6537 salt_type = SALT_TYPE_NONE;
6538 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6539 opts_type = OPTS_TYPE_PT_GENERATE_LE
6540 | OPTS_TYPE_PT_ADD80
6541 | OPTS_TYPE_PT_ADDBITS14;
6542 kern_type = KERN_TYPE_MD5;
6543 dgst_size = DGST_SIZE_4_4;
6544 parse_func = md5_parse_hash;
6545 sort_by_digest = sort_by_digest_4_4;
6546 opti_type = OPTI_TYPE_ZERO_BYTE
6547 | OPTI_TYPE_PRECOMPUTE_INIT
6548 | OPTI_TYPE_PRECOMPUTE_MERKLE
6549 | OPTI_TYPE_MEET_IN_MIDDLE
6550 | OPTI_TYPE_EARLY_SKIP
6551 | OPTI_TYPE_NOT_ITERATED
6552 | OPTI_TYPE_NOT_SALTED
6553 | OPTI_TYPE_RAW_HASH;
6554 dgst_pos0 = 0;
6555 dgst_pos1 = 3;
6556 dgst_pos2 = 2;
6557 dgst_pos3 = 1;
6558 break;
6559
6560 case 10: hash_type = HASH_TYPE_MD5;
6561 salt_type = SALT_TYPE_INTERN;
6562 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6563 opts_type = OPTS_TYPE_PT_GENERATE_LE
6564 | OPTS_TYPE_ST_ADD80
6565 | OPTS_TYPE_ST_ADDBITS14;
6566 kern_type = KERN_TYPE_MD5_PWSLT;
6567 dgst_size = DGST_SIZE_4_4;
6568 parse_func = md5s_parse_hash;
6569 sort_by_digest = sort_by_digest_4_4;
6570 opti_type = OPTI_TYPE_ZERO_BYTE
6571 | OPTI_TYPE_PRECOMPUTE_INIT
6572 | OPTI_TYPE_PRECOMPUTE_MERKLE
6573 | OPTI_TYPE_MEET_IN_MIDDLE
6574 | OPTI_TYPE_EARLY_SKIP
6575 | OPTI_TYPE_NOT_ITERATED
6576 | OPTI_TYPE_APPENDED_SALT
6577 | OPTI_TYPE_RAW_HASH;
6578 dgst_pos0 = 0;
6579 dgst_pos1 = 3;
6580 dgst_pos2 = 2;
6581 dgst_pos3 = 1;
6582 break;
6583
6584 case 11: hash_type = HASH_TYPE_MD5;
6585 salt_type = SALT_TYPE_INTERN;
6586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6587 opts_type = OPTS_TYPE_PT_GENERATE_LE
6588 | OPTS_TYPE_ST_ADD80
6589 | OPTS_TYPE_ST_ADDBITS14;
6590 kern_type = KERN_TYPE_MD5_PWSLT;
6591 dgst_size = DGST_SIZE_4_4;
6592 parse_func = joomla_parse_hash;
6593 sort_by_digest = sort_by_digest_4_4;
6594 opti_type = OPTI_TYPE_ZERO_BYTE
6595 | OPTI_TYPE_PRECOMPUTE_INIT
6596 | OPTI_TYPE_PRECOMPUTE_MERKLE
6597 | OPTI_TYPE_MEET_IN_MIDDLE
6598 | OPTI_TYPE_EARLY_SKIP
6599 | OPTI_TYPE_NOT_ITERATED
6600 | OPTI_TYPE_APPENDED_SALT
6601 | OPTI_TYPE_RAW_HASH;
6602 dgst_pos0 = 0;
6603 dgst_pos1 = 3;
6604 dgst_pos2 = 2;
6605 dgst_pos3 = 1;
6606 break;
6607
6608 case 12: hash_type = HASH_TYPE_MD5;
6609 salt_type = SALT_TYPE_INTERN;
6610 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6611 opts_type = OPTS_TYPE_PT_GENERATE_LE
6612 | OPTS_TYPE_ST_ADD80
6613 | OPTS_TYPE_ST_ADDBITS14;
6614 kern_type = KERN_TYPE_MD5_PWSLT;
6615 dgst_size = DGST_SIZE_4_4;
6616 parse_func = postgresql_parse_hash;
6617 sort_by_digest = sort_by_digest_4_4;
6618 opti_type = OPTI_TYPE_ZERO_BYTE
6619 | OPTI_TYPE_PRECOMPUTE_INIT
6620 | OPTI_TYPE_PRECOMPUTE_MERKLE
6621 | OPTI_TYPE_MEET_IN_MIDDLE
6622 | OPTI_TYPE_EARLY_SKIP
6623 | OPTI_TYPE_NOT_ITERATED
6624 | OPTI_TYPE_APPENDED_SALT
6625 | OPTI_TYPE_RAW_HASH;
6626 dgst_pos0 = 0;
6627 dgst_pos1 = 3;
6628 dgst_pos2 = 2;
6629 dgst_pos3 = 1;
6630 break;
6631
6632 case 20: hash_type = HASH_TYPE_MD5;
6633 salt_type = SALT_TYPE_INTERN;
6634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6635 opts_type = OPTS_TYPE_PT_GENERATE_LE
6636 | OPTS_TYPE_PT_ADD80
6637 | OPTS_TYPE_PT_ADDBITS14;
6638 kern_type = KERN_TYPE_MD5_SLTPW;
6639 dgst_size = DGST_SIZE_4_4;
6640 parse_func = md5s_parse_hash;
6641 sort_by_digest = sort_by_digest_4_4;
6642 opti_type = OPTI_TYPE_ZERO_BYTE
6643 | OPTI_TYPE_PRECOMPUTE_INIT
6644 | OPTI_TYPE_PRECOMPUTE_MERKLE
6645 | OPTI_TYPE_EARLY_SKIP
6646 | OPTI_TYPE_NOT_ITERATED
6647 | OPTI_TYPE_PREPENDED_SALT
6648 | OPTI_TYPE_RAW_HASH;
6649 dgst_pos0 = 0;
6650 dgst_pos1 = 3;
6651 dgst_pos2 = 2;
6652 dgst_pos3 = 1;
6653 break;
6654
6655 case 21: hash_type = HASH_TYPE_MD5;
6656 salt_type = SALT_TYPE_INTERN;
6657 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6658 opts_type = OPTS_TYPE_PT_GENERATE_LE
6659 | OPTS_TYPE_PT_ADD80
6660 | OPTS_TYPE_PT_ADDBITS14;
6661 kern_type = KERN_TYPE_MD5_SLTPW;
6662 dgst_size = DGST_SIZE_4_4;
6663 parse_func = osc_parse_hash;
6664 sort_by_digest = sort_by_digest_4_4;
6665 opti_type = OPTI_TYPE_ZERO_BYTE
6666 | OPTI_TYPE_PRECOMPUTE_INIT
6667 | OPTI_TYPE_PRECOMPUTE_MERKLE
6668 | OPTI_TYPE_EARLY_SKIP
6669 | OPTI_TYPE_NOT_ITERATED
6670 | OPTI_TYPE_PREPENDED_SALT
6671 | OPTI_TYPE_RAW_HASH;
6672 dgst_pos0 = 0;
6673 dgst_pos1 = 3;
6674 dgst_pos2 = 2;
6675 dgst_pos3 = 1;
6676 break;
6677
6678 case 22: hash_type = HASH_TYPE_MD5;
6679 salt_type = SALT_TYPE_EMBEDDED;
6680 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6681 opts_type = OPTS_TYPE_PT_GENERATE_LE
6682 | OPTS_TYPE_PT_ADD80
6683 | OPTS_TYPE_PT_ADDBITS14;
6684 kern_type = KERN_TYPE_MD5_SLTPW;
6685 dgst_size = DGST_SIZE_4_4;
6686 parse_func = netscreen_parse_hash;
6687 sort_by_digest = sort_by_digest_4_4;
6688 opti_type = OPTI_TYPE_ZERO_BYTE
6689 | OPTI_TYPE_PRECOMPUTE_INIT
6690 | OPTI_TYPE_PRECOMPUTE_MERKLE
6691 | OPTI_TYPE_EARLY_SKIP
6692 | OPTI_TYPE_NOT_ITERATED
6693 | OPTI_TYPE_PREPENDED_SALT
6694 | OPTI_TYPE_RAW_HASH;
6695 dgst_pos0 = 0;
6696 dgst_pos1 = 3;
6697 dgst_pos2 = 2;
6698 dgst_pos3 = 1;
6699 break;
6700
6701 case 23: hash_type = HASH_TYPE_MD5;
6702 salt_type = SALT_TYPE_EMBEDDED;
6703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6704 opts_type = OPTS_TYPE_PT_GENERATE_LE
6705 | OPTS_TYPE_PT_ADD80
6706 | OPTS_TYPE_PT_ADDBITS14;
6707 kern_type = KERN_TYPE_MD5_SLTPW;
6708 dgst_size = DGST_SIZE_4_4;
6709 parse_func = skype_parse_hash;
6710 sort_by_digest = sort_by_digest_4_4;
6711 opti_type = OPTI_TYPE_ZERO_BYTE
6712 | OPTI_TYPE_PRECOMPUTE_INIT
6713 | OPTI_TYPE_PRECOMPUTE_MERKLE
6714 | OPTI_TYPE_EARLY_SKIP
6715 | OPTI_TYPE_NOT_ITERATED
6716 | OPTI_TYPE_PREPENDED_SALT
6717 | OPTI_TYPE_RAW_HASH;
6718 dgst_pos0 = 0;
6719 dgst_pos1 = 3;
6720 dgst_pos2 = 2;
6721 dgst_pos3 = 1;
6722 break;
6723
6724 case 30: hash_type = HASH_TYPE_MD5;
6725 salt_type = SALT_TYPE_INTERN;
6726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6727 opts_type = OPTS_TYPE_PT_GENERATE_LE
6728 | OPTS_TYPE_PT_UNICODE
6729 | OPTS_TYPE_ST_ADD80
6730 | OPTS_TYPE_ST_ADDBITS14;
6731 kern_type = KERN_TYPE_MD5_PWUSLT;
6732 dgst_size = DGST_SIZE_4_4;
6733 parse_func = md5s_parse_hash;
6734 sort_by_digest = sort_by_digest_4_4;
6735 opti_type = OPTI_TYPE_ZERO_BYTE
6736 | OPTI_TYPE_PRECOMPUTE_INIT
6737 | OPTI_TYPE_PRECOMPUTE_MERKLE
6738 | OPTI_TYPE_MEET_IN_MIDDLE
6739 | OPTI_TYPE_EARLY_SKIP
6740 | OPTI_TYPE_NOT_ITERATED
6741 | OPTI_TYPE_APPENDED_SALT
6742 | OPTI_TYPE_RAW_HASH;
6743 dgst_pos0 = 0;
6744 dgst_pos1 = 3;
6745 dgst_pos2 = 2;
6746 dgst_pos3 = 1;
6747 break;
6748
6749 case 40: hash_type = HASH_TYPE_MD5;
6750 salt_type = SALT_TYPE_INTERN;
6751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6752 opts_type = OPTS_TYPE_PT_GENERATE_LE
6753 | OPTS_TYPE_PT_ADD80
6754 | OPTS_TYPE_PT_ADDBITS14
6755 | OPTS_TYPE_PT_UNICODE;
6756 kern_type = KERN_TYPE_MD5_SLTPWU;
6757 dgst_size = DGST_SIZE_4_4;
6758 parse_func = md5s_parse_hash;
6759 sort_by_digest = sort_by_digest_4_4;
6760 opti_type = OPTI_TYPE_ZERO_BYTE
6761 | OPTI_TYPE_PRECOMPUTE_INIT
6762 | OPTI_TYPE_PRECOMPUTE_MERKLE
6763 | OPTI_TYPE_EARLY_SKIP
6764 | OPTI_TYPE_NOT_ITERATED
6765 | OPTI_TYPE_PREPENDED_SALT
6766 | OPTI_TYPE_RAW_HASH;
6767 dgst_pos0 = 0;
6768 dgst_pos1 = 3;
6769 dgst_pos2 = 2;
6770 dgst_pos3 = 1;
6771 break;
6772
6773 case 50: hash_type = HASH_TYPE_MD5;
6774 salt_type = SALT_TYPE_INTERN;
6775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6776 opts_type = OPTS_TYPE_PT_GENERATE_LE
6777 | OPTS_TYPE_ST_ADD80
6778 | OPTS_TYPE_ST_ADDBITS14;
6779 kern_type = KERN_TYPE_HMACMD5_PW;
6780 dgst_size = DGST_SIZE_4_4;
6781 parse_func = hmacmd5_parse_hash;
6782 sort_by_digest = sort_by_digest_4_4;
6783 opti_type = OPTI_TYPE_ZERO_BYTE
6784 | OPTI_TYPE_NOT_ITERATED;
6785 dgst_pos0 = 0;
6786 dgst_pos1 = 3;
6787 dgst_pos2 = 2;
6788 dgst_pos3 = 1;
6789 break;
6790
6791 case 60: hash_type = HASH_TYPE_MD5;
6792 salt_type = SALT_TYPE_INTERN;
6793 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6794 opts_type = OPTS_TYPE_PT_GENERATE_LE
6795 | OPTS_TYPE_PT_ADD80
6796 | OPTS_TYPE_PT_ADDBITS14;
6797 kern_type = KERN_TYPE_HMACMD5_SLT;
6798 dgst_size = DGST_SIZE_4_4;
6799 parse_func = hmacmd5_parse_hash;
6800 sort_by_digest = sort_by_digest_4_4;
6801 opti_type = OPTI_TYPE_ZERO_BYTE
6802 | OPTI_TYPE_NOT_ITERATED;
6803 dgst_pos0 = 0;
6804 dgst_pos1 = 3;
6805 dgst_pos2 = 2;
6806 dgst_pos3 = 1;
6807 break;
6808
6809 case 100: hash_type = HASH_TYPE_SHA1;
6810 salt_type = SALT_TYPE_NONE;
6811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6812 opts_type = OPTS_TYPE_PT_GENERATE_BE
6813 | OPTS_TYPE_PT_ADD80
6814 | OPTS_TYPE_PT_ADDBITS15;
6815 kern_type = KERN_TYPE_SHA1;
6816 dgst_size = DGST_SIZE_4_5;
6817 parse_func = sha1_parse_hash;
6818 sort_by_digest = sort_by_digest_4_5;
6819 opti_type = OPTI_TYPE_ZERO_BYTE
6820 | OPTI_TYPE_PRECOMPUTE_INIT
6821 | OPTI_TYPE_PRECOMPUTE_MERKLE
6822 | OPTI_TYPE_EARLY_SKIP
6823 | OPTI_TYPE_NOT_ITERATED
6824 | OPTI_TYPE_NOT_SALTED
6825 | OPTI_TYPE_RAW_HASH;
6826 dgst_pos0 = 3;
6827 dgst_pos1 = 4;
6828 dgst_pos2 = 2;
6829 dgst_pos3 = 1;
6830 break;
6831
6832 case 101: hash_type = HASH_TYPE_SHA1;
6833 salt_type = SALT_TYPE_NONE;
6834 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6835 opts_type = OPTS_TYPE_PT_GENERATE_BE
6836 | OPTS_TYPE_PT_ADD80
6837 | OPTS_TYPE_PT_ADDBITS15;
6838 kern_type = KERN_TYPE_SHA1;
6839 dgst_size = DGST_SIZE_4_5;
6840 parse_func = sha1b64_parse_hash;
6841 sort_by_digest = sort_by_digest_4_5;
6842 opti_type = OPTI_TYPE_ZERO_BYTE
6843 | OPTI_TYPE_PRECOMPUTE_INIT
6844 | OPTI_TYPE_PRECOMPUTE_MERKLE
6845 | OPTI_TYPE_EARLY_SKIP
6846 | OPTI_TYPE_NOT_ITERATED
6847 | OPTI_TYPE_NOT_SALTED
6848 | OPTI_TYPE_RAW_HASH;
6849 dgst_pos0 = 3;
6850 dgst_pos1 = 4;
6851 dgst_pos2 = 2;
6852 dgst_pos3 = 1;
6853 break;
6854
6855 case 110: hash_type = HASH_TYPE_SHA1;
6856 salt_type = SALT_TYPE_INTERN;
6857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6858 opts_type = OPTS_TYPE_PT_GENERATE_BE
6859 | OPTS_TYPE_ST_ADD80
6860 | OPTS_TYPE_ST_ADDBITS15;
6861 kern_type = KERN_TYPE_SHA1_PWSLT;
6862 dgst_size = DGST_SIZE_4_5;
6863 parse_func = sha1s_parse_hash;
6864 sort_by_digest = sort_by_digest_4_5;
6865 opti_type = OPTI_TYPE_ZERO_BYTE
6866 | OPTI_TYPE_PRECOMPUTE_INIT
6867 | OPTI_TYPE_PRECOMPUTE_MERKLE
6868 | OPTI_TYPE_EARLY_SKIP
6869 | OPTI_TYPE_NOT_ITERATED
6870 | OPTI_TYPE_APPENDED_SALT
6871 | OPTI_TYPE_RAW_HASH;
6872 dgst_pos0 = 3;
6873 dgst_pos1 = 4;
6874 dgst_pos2 = 2;
6875 dgst_pos3 = 1;
6876 break;
6877
6878 case 111: hash_type = HASH_TYPE_SHA1;
6879 salt_type = SALT_TYPE_EMBEDDED;
6880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6881 opts_type = OPTS_TYPE_PT_GENERATE_BE
6882 | OPTS_TYPE_ST_ADD80
6883 | OPTS_TYPE_ST_ADDBITS15;
6884 kern_type = KERN_TYPE_SHA1_PWSLT;
6885 dgst_size = DGST_SIZE_4_5;
6886 parse_func = sha1b64s_parse_hash;
6887 sort_by_digest = sort_by_digest_4_5;
6888 opti_type = OPTI_TYPE_ZERO_BYTE
6889 | OPTI_TYPE_PRECOMPUTE_INIT
6890 | OPTI_TYPE_PRECOMPUTE_MERKLE
6891 | OPTI_TYPE_EARLY_SKIP
6892 | OPTI_TYPE_NOT_ITERATED
6893 | OPTI_TYPE_APPENDED_SALT
6894 | OPTI_TYPE_RAW_HASH;
6895 dgst_pos0 = 3;
6896 dgst_pos1 = 4;
6897 dgst_pos2 = 2;
6898 dgst_pos3 = 1;
6899 break;
6900
6901 case 112: hash_type = HASH_TYPE_SHA1;
6902 salt_type = SALT_TYPE_INTERN;
6903 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6904 opts_type = OPTS_TYPE_PT_GENERATE_BE
6905 | OPTS_TYPE_ST_ADD80
6906 | OPTS_TYPE_ST_ADDBITS15
6907 | OPTS_TYPE_ST_HEX;
6908 kern_type = KERN_TYPE_SHA1_PWSLT;
6909 dgst_size = DGST_SIZE_4_5;
6910 parse_func = oracles_parse_hash;
6911 sort_by_digest = sort_by_digest_4_5;
6912 opti_type = OPTI_TYPE_ZERO_BYTE
6913 | OPTI_TYPE_PRECOMPUTE_INIT
6914 | OPTI_TYPE_PRECOMPUTE_MERKLE
6915 | OPTI_TYPE_EARLY_SKIP
6916 | OPTI_TYPE_NOT_ITERATED
6917 | OPTI_TYPE_APPENDED_SALT
6918 | OPTI_TYPE_RAW_HASH;
6919 dgst_pos0 = 3;
6920 dgst_pos1 = 4;
6921 dgst_pos2 = 2;
6922 dgst_pos3 = 1;
6923 break;
6924
6925 case 120: hash_type = HASH_TYPE_SHA1;
6926 salt_type = SALT_TYPE_INTERN;
6927 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6928 opts_type = OPTS_TYPE_PT_GENERATE_BE
6929 | OPTS_TYPE_PT_ADD80
6930 | OPTS_TYPE_PT_ADDBITS15;
6931 kern_type = KERN_TYPE_SHA1_SLTPW;
6932 dgst_size = DGST_SIZE_4_5;
6933 parse_func = sha1s_parse_hash;
6934 sort_by_digest = sort_by_digest_4_5;
6935 opti_type = OPTI_TYPE_ZERO_BYTE
6936 | OPTI_TYPE_PRECOMPUTE_INIT
6937 | OPTI_TYPE_PRECOMPUTE_MERKLE
6938 | OPTI_TYPE_EARLY_SKIP
6939 | OPTI_TYPE_NOT_ITERATED
6940 | OPTI_TYPE_PREPENDED_SALT
6941 | OPTI_TYPE_RAW_HASH;
6942 dgst_pos0 = 3;
6943 dgst_pos1 = 4;
6944 dgst_pos2 = 2;
6945 dgst_pos3 = 1;
6946 break;
6947
6948 case 121: hash_type = HASH_TYPE_SHA1;
6949 salt_type = SALT_TYPE_INTERN;
6950 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6951 opts_type = OPTS_TYPE_PT_GENERATE_BE
6952 | OPTS_TYPE_PT_ADD80
6953 | OPTS_TYPE_PT_ADDBITS15
6954 | OPTS_TYPE_ST_LOWER;
6955 kern_type = KERN_TYPE_SHA1_SLTPW;
6956 dgst_size = DGST_SIZE_4_5;
6957 parse_func = smf_parse_hash;
6958 sort_by_digest = sort_by_digest_4_5;
6959 opti_type = OPTI_TYPE_ZERO_BYTE
6960 | OPTI_TYPE_PRECOMPUTE_INIT
6961 | OPTI_TYPE_PRECOMPUTE_MERKLE
6962 | OPTI_TYPE_EARLY_SKIP
6963 | OPTI_TYPE_NOT_ITERATED
6964 | OPTI_TYPE_PREPENDED_SALT
6965 | OPTI_TYPE_RAW_HASH;
6966 dgst_pos0 = 3;
6967 dgst_pos1 = 4;
6968 dgst_pos2 = 2;
6969 dgst_pos3 = 1;
6970 break;
6971
6972 case 122: hash_type = HASH_TYPE_SHA1;
6973 salt_type = SALT_TYPE_EMBEDDED;
6974 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6975 opts_type = OPTS_TYPE_PT_GENERATE_BE
6976 | OPTS_TYPE_PT_ADD80
6977 | OPTS_TYPE_PT_ADDBITS15
6978 | OPTS_TYPE_ST_HEX;
6979 kern_type = KERN_TYPE_SHA1_SLTPW;
6980 dgst_size = DGST_SIZE_4_5;
6981 parse_func = osx1_parse_hash;
6982 sort_by_digest = sort_by_digest_4_5;
6983 opti_type = OPTI_TYPE_ZERO_BYTE
6984 | OPTI_TYPE_PRECOMPUTE_INIT
6985 | OPTI_TYPE_PRECOMPUTE_MERKLE
6986 | OPTI_TYPE_EARLY_SKIP
6987 | OPTI_TYPE_NOT_ITERATED
6988 | OPTI_TYPE_PREPENDED_SALT
6989 | OPTI_TYPE_RAW_HASH;
6990 dgst_pos0 = 3;
6991 dgst_pos1 = 4;
6992 dgst_pos2 = 2;
6993 dgst_pos3 = 1;
6994 break;
6995
6996 case 124: hash_type = HASH_TYPE_SHA1;
6997 salt_type = SALT_TYPE_EMBEDDED;
6998 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6999 opts_type = OPTS_TYPE_PT_GENERATE_BE
7000 | OPTS_TYPE_PT_ADD80
7001 | OPTS_TYPE_PT_ADDBITS15;
7002 kern_type = KERN_TYPE_SHA1_SLTPW;
7003 dgst_size = DGST_SIZE_4_5;
7004 parse_func = djangosha1_parse_hash;
7005 sort_by_digest = sort_by_digest_4_5;
7006 opti_type = OPTI_TYPE_ZERO_BYTE
7007 | OPTI_TYPE_PRECOMPUTE_INIT
7008 | OPTI_TYPE_PRECOMPUTE_MERKLE
7009 | OPTI_TYPE_EARLY_SKIP
7010 | OPTI_TYPE_NOT_ITERATED
7011 | OPTI_TYPE_PREPENDED_SALT
7012 | OPTI_TYPE_RAW_HASH;
7013 dgst_pos0 = 3;
7014 dgst_pos1 = 4;
7015 dgst_pos2 = 2;
7016 dgst_pos3 = 1;
7017 break;
7018
7019 case 130: hash_type = HASH_TYPE_SHA1;
7020 salt_type = SALT_TYPE_INTERN;
7021 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7022 opts_type = OPTS_TYPE_PT_GENERATE_BE
7023 | OPTS_TYPE_PT_UNICODE
7024 | OPTS_TYPE_ST_ADD80
7025 | OPTS_TYPE_ST_ADDBITS15;
7026 kern_type = KERN_TYPE_SHA1_PWUSLT;
7027 dgst_size = DGST_SIZE_4_5;
7028 parse_func = sha1s_parse_hash;
7029 sort_by_digest = sort_by_digest_4_5;
7030 opti_type = OPTI_TYPE_ZERO_BYTE
7031 | OPTI_TYPE_PRECOMPUTE_INIT
7032 | OPTI_TYPE_PRECOMPUTE_MERKLE
7033 | OPTI_TYPE_EARLY_SKIP
7034 | OPTI_TYPE_NOT_ITERATED
7035 | OPTI_TYPE_APPENDED_SALT
7036 | OPTI_TYPE_RAW_HASH;
7037 dgst_pos0 = 3;
7038 dgst_pos1 = 4;
7039 dgst_pos2 = 2;
7040 dgst_pos3 = 1;
7041 break;
7042
7043 case 131: hash_type = HASH_TYPE_SHA1;
7044 salt_type = SALT_TYPE_EMBEDDED;
7045 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7046 opts_type = OPTS_TYPE_PT_GENERATE_BE
7047 | OPTS_TYPE_PT_UNICODE
7048 | OPTS_TYPE_PT_UPPER
7049 | OPTS_TYPE_ST_ADD80
7050 | OPTS_TYPE_ST_ADDBITS15
7051 | OPTS_TYPE_ST_HEX;
7052 kern_type = KERN_TYPE_SHA1_PWUSLT;
7053 dgst_size = DGST_SIZE_4_5;
7054 parse_func = mssql2000_parse_hash;
7055 sort_by_digest = sort_by_digest_4_5;
7056 opti_type = OPTI_TYPE_ZERO_BYTE
7057 | OPTI_TYPE_PRECOMPUTE_INIT
7058 | OPTI_TYPE_PRECOMPUTE_MERKLE
7059 | OPTI_TYPE_EARLY_SKIP
7060 | OPTI_TYPE_NOT_ITERATED
7061 | OPTI_TYPE_APPENDED_SALT
7062 | OPTI_TYPE_RAW_HASH;
7063 dgst_pos0 = 3;
7064 dgst_pos1 = 4;
7065 dgst_pos2 = 2;
7066 dgst_pos3 = 1;
7067 break;
7068
7069 case 132: hash_type = HASH_TYPE_SHA1;
7070 salt_type = SALT_TYPE_EMBEDDED;
7071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7072 opts_type = OPTS_TYPE_PT_GENERATE_BE
7073 | OPTS_TYPE_PT_UNICODE
7074 | OPTS_TYPE_ST_ADD80
7075 | OPTS_TYPE_ST_ADDBITS15
7076 | OPTS_TYPE_ST_HEX;
7077 kern_type = KERN_TYPE_SHA1_PWUSLT;
7078 dgst_size = DGST_SIZE_4_5;
7079 parse_func = mssql2005_parse_hash;
7080 sort_by_digest = sort_by_digest_4_5;
7081 opti_type = OPTI_TYPE_ZERO_BYTE
7082 | OPTI_TYPE_PRECOMPUTE_INIT
7083 | OPTI_TYPE_PRECOMPUTE_MERKLE
7084 | OPTI_TYPE_EARLY_SKIP
7085 | OPTI_TYPE_NOT_ITERATED
7086 | OPTI_TYPE_APPENDED_SALT
7087 | OPTI_TYPE_RAW_HASH;
7088 dgst_pos0 = 3;
7089 dgst_pos1 = 4;
7090 dgst_pos2 = 2;
7091 dgst_pos3 = 1;
7092 break;
7093
7094 case 133: hash_type = HASH_TYPE_SHA1;
7095 salt_type = SALT_TYPE_EMBEDDED;
7096 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7097 opts_type = OPTS_TYPE_PT_GENERATE_BE
7098 | OPTS_TYPE_PT_UNICODE
7099 | OPTS_TYPE_ST_ADD80
7100 | OPTS_TYPE_ST_ADDBITS15;
7101 kern_type = KERN_TYPE_SHA1_PWUSLT;
7102 dgst_size = DGST_SIZE_4_5;
7103 parse_func = peoplesoft_parse_hash;
7104 sort_by_digest = sort_by_digest_4_5;
7105 opti_type = OPTI_TYPE_ZERO_BYTE
7106 | OPTI_TYPE_PRECOMPUTE_INIT
7107 | OPTI_TYPE_PRECOMPUTE_MERKLE
7108 | OPTI_TYPE_EARLY_SKIP
7109 | OPTI_TYPE_NOT_ITERATED
7110 | OPTI_TYPE_APPENDED_SALT
7111 | OPTI_TYPE_RAW_HASH;
7112 dgst_pos0 = 3;
7113 dgst_pos1 = 4;
7114 dgst_pos2 = 2;
7115 dgst_pos3 = 1;
7116 break;
7117
7118 case 140: hash_type = HASH_TYPE_SHA1;
7119 salt_type = SALT_TYPE_INTERN;
7120 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7121 opts_type = OPTS_TYPE_PT_GENERATE_BE
7122 | OPTS_TYPE_PT_ADD80
7123 | OPTS_TYPE_PT_ADDBITS15
7124 | OPTS_TYPE_PT_UNICODE;
7125 kern_type = KERN_TYPE_SHA1_SLTPWU;
7126 dgst_size = DGST_SIZE_4_5;
7127 parse_func = sha1s_parse_hash;
7128 sort_by_digest = sort_by_digest_4_5;
7129 opti_type = OPTI_TYPE_ZERO_BYTE
7130 | OPTI_TYPE_PRECOMPUTE_INIT
7131 | OPTI_TYPE_PRECOMPUTE_MERKLE
7132 | OPTI_TYPE_EARLY_SKIP
7133 | OPTI_TYPE_NOT_ITERATED
7134 | OPTI_TYPE_PREPENDED_SALT
7135 | OPTI_TYPE_RAW_HASH;
7136 dgst_pos0 = 3;
7137 dgst_pos1 = 4;
7138 dgst_pos2 = 2;
7139 dgst_pos3 = 1;
7140 break;
7141
7142 case 141: hash_type = HASH_TYPE_SHA1;
7143 salt_type = SALT_TYPE_EMBEDDED;
7144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7145 opts_type = OPTS_TYPE_PT_GENERATE_BE
7146 | OPTS_TYPE_PT_ADD80
7147 | OPTS_TYPE_PT_ADDBITS15
7148 | OPTS_TYPE_PT_UNICODE
7149 | OPTS_TYPE_ST_BASE64;
7150 kern_type = KERN_TYPE_SHA1_SLTPWU;
7151 dgst_size = DGST_SIZE_4_5;
7152 parse_func = episerver_parse_hash;
7153 sort_by_digest = sort_by_digest_4_5;
7154 opti_type = OPTI_TYPE_ZERO_BYTE
7155 | OPTI_TYPE_PRECOMPUTE_INIT
7156 | OPTI_TYPE_PRECOMPUTE_MERKLE
7157 | OPTI_TYPE_EARLY_SKIP
7158 | OPTI_TYPE_NOT_ITERATED
7159 | OPTI_TYPE_PREPENDED_SALT
7160 | OPTI_TYPE_RAW_HASH;
7161 dgst_pos0 = 3;
7162 dgst_pos1 = 4;
7163 dgst_pos2 = 2;
7164 dgst_pos3 = 1;
7165 break;
7166
7167 case 150: hash_type = HASH_TYPE_SHA1;
7168 salt_type = SALT_TYPE_INTERN;
7169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7170 opts_type = OPTS_TYPE_PT_GENERATE_BE
7171 | OPTS_TYPE_ST_ADD80
7172 | OPTS_TYPE_ST_ADDBITS15;
7173 kern_type = KERN_TYPE_HMACSHA1_PW;
7174 dgst_size = DGST_SIZE_4_5;
7175 parse_func = hmacsha1_parse_hash;
7176 sort_by_digest = sort_by_digest_4_5;
7177 opti_type = OPTI_TYPE_ZERO_BYTE
7178 | OPTI_TYPE_NOT_ITERATED;
7179 dgst_pos0 = 3;
7180 dgst_pos1 = 4;
7181 dgst_pos2 = 2;
7182 dgst_pos3 = 1;
7183 break;
7184
7185 case 160: hash_type = HASH_TYPE_SHA1;
7186 salt_type = SALT_TYPE_INTERN;
7187 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7188 opts_type = OPTS_TYPE_PT_GENERATE_BE
7189 | OPTS_TYPE_PT_ADD80
7190 | OPTS_TYPE_PT_ADDBITS15;
7191 kern_type = KERN_TYPE_HMACSHA1_SLT;
7192 dgst_size = DGST_SIZE_4_5;
7193 parse_func = hmacsha1_parse_hash;
7194 sort_by_digest = sort_by_digest_4_5;
7195 opti_type = OPTI_TYPE_ZERO_BYTE
7196 | OPTI_TYPE_NOT_ITERATED;
7197 dgst_pos0 = 3;
7198 dgst_pos1 = 4;
7199 dgst_pos2 = 2;
7200 dgst_pos3 = 1;
7201 break;
7202
7203 case 190: hash_type = HASH_TYPE_SHA1;
7204 salt_type = SALT_TYPE_NONE;
7205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7206 opts_type = OPTS_TYPE_PT_GENERATE_BE
7207 | OPTS_TYPE_PT_ADD80
7208 | OPTS_TYPE_PT_ADDBITS15;
7209 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7210 dgst_size = DGST_SIZE_4_5;
7211 parse_func = sha1linkedin_parse_hash;
7212 sort_by_digest = sort_by_digest_4_5;
7213 opti_type = OPTI_TYPE_ZERO_BYTE
7214 | OPTI_TYPE_PRECOMPUTE_INIT
7215 | OPTI_TYPE_EARLY_SKIP
7216 | OPTI_TYPE_NOT_ITERATED
7217 | OPTI_TYPE_NOT_SALTED;
7218 dgst_pos0 = 0;
7219 dgst_pos1 = 4;
7220 dgst_pos2 = 3;
7221 dgst_pos3 = 2;
7222 break;
7223
7224 case 200: hash_type = HASH_TYPE_MYSQL;
7225 salt_type = SALT_TYPE_NONE;
7226 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7227 opts_type = 0;
7228 kern_type = KERN_TYPE_MYSQL;
7229 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7230 parse_func = mysql323_parse_hash;
7231 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7232 opti_type = OPTI_TYPE_ZERO_BYTE;
7233 dgst_pos0 = 0;
7234 dgst_pos1 = 1;
7235 dgst_pos2 = 2;
7236 dgst_pos3 = 3;
7237 break;
7238
7239 case 300: hash_type = HASH_TYPE_SHA1;
7240 salt_type = SALT_TYPE_NONE;
7241 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7242 opts_type = OPTS_TYPE_PT_GENERATE_BE
7243 | OPTS_TYPE_PT_ADD80
7244 | OPTS_TYPE_PT_ADDBITS15;
7245 kern_type = KERN_TYPE_MYSQL41;
7246 dgst_size = DGST_SIZE_4_5;
7247 parse_func = sha1_parse_hash;
7248 sort_by_digest = sort_by_digest_4_5;
7249 opti_type = OPTI_TYPE_ZERO_BYTE
7250 | OPTI_TYPE_PRECOMPUTE_INIT
7251 | OPTI_TYPE_PRECOMPUTE_MERKLE
7252 | OPTI_TYPE_EARLY_SKIP
7253 | OPTI_TYPE_NOT_ITERATED
7254 | OPTI_TYPE_NOT_SALTED;
7255 dgst_pos0 = 3;
7256 dgst_pos1 = 4;
7257 dgst_pos2 = 2;
7258 dgst_pos3 = 1;
7259 break;
7260
7261 case 400: hash_type = HASH_TYPE_MD5;
7262 salt_type = SALT_TYPE_EMBEDDED;
7263 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7264 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7265 kern_type = KERN_TYPE_PHPASS;
7266 dgst_size = DGST_SIZE_4_4;
7267 parse_func = phpass_parse_hash;
7268 sort_by_digest = sort_by_digest_4_4;
7269 opti_type = OPTI_TYPE_ZERO_BYTE;
7270 dgst_pos0 = 0;
7271 dgst_pos1 = 1;
7272 dgst_pos2 = 2;
7273 dgst_pos3 = 3;
7274 break;
7275
7276 case 500: hash_type = HASH_TYPE_MD5;
7277 salt_type = SALT_TYPE_EMBEDDED;
7278 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7279 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7280 kern_type = KERN_TYPE_MD5CRYPT;
7281 dgst_size = DGST_SIZE_4_4;
7282 parse_func = md5crypt_parse_hash;
7283 sort_by_digest = sort_by_digest_4_4;
7284 opti_type = OPTI_TYPE_ZERO_BYTE;
7285 dgst_pos0 = 0;
7286 dgst_pos1 = 1;
7287 dgst_pos2 = 2;
7288 dgst_pos3 = 3;
7289 break;
7290
7291 case 501: hash_type = HASH_TYPE_MD5;
7292 salt_type = SALT_TYPE_EMBEDDED;
7293 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7294 opts_type = OPTS_TYPE_PT_GENERATE_LE
7295 | OPTS_TYPE_HASH_COPY;
7296 kern_type = KERN_TYPE_MD5CRYPT;
7297 dgst_size = DGST_SIZE_4_4;
7298 parse_func = juniper_parse_hash;
7299 sort_by_digest = sort_by_digest_4_4;
7300 opti_type = OPTI_TYPE_ZERO_BYTE;
7301 dgst_pos0 = 0;
7302 dgst_pos1 = 1;
7303 dgst_pos2 = 2;
7304 dgst_pos3 = 3;
7305 break;
7306
7307 case 900: hash_type = HASH_TYPE_MD4;
7308 salt_type = SALT_TYPE_NONE;
7309 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7310 opts_type = OPTS_TYPE_PT_GENERATE_LE
7311 | OPTS_TYPE_PT_ADD80
7312 | OPTS_TYPE_PT_ADDBITS14;
7313 kern_type = KERN_TYPE_MD4;
7314 dgst_size = DGST_SIZE_4_4;
7315 parse_func = md4_parse_hash;
7316 sort_by_digest = sort_by_digest_4_4;
7317 opti_type = OPTI_TYPE_ZERO_BYTE
7318 | OPTI_TYPE_PRECOMPUTE_INIT
7319 | OPTI_TYPE_PRECOMPUTE_MERKLE
7320 | OPTI_TYPE_MEET_IN_MIDDLE
7321 | OPTI_TYPE_EARLY_SKIP
7322 | OPTI_TYPE_NOT_ITERATED
7323 | OPTI_TYPE_NOT_SALTED
7324 | OPTI_TYPE_RAW_HASH;
7325 dgst_pos0 = 0;
7326 dgst_pos1 = 3;
7327 dgst_pos2 = 2;
7328 dgst_pos3 = 1;
7329 break;
7330
7331 case 1000: hash_type = HASH_TYPE_MD4;
7332 salt_type = SALT_TYPE_NONE;
7333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7334 opts_type = OPTS_TYPE_PT_GENERATE_LE
7335 | OPTS_TYPE_PT_ADD80
7336 | OPTS_TYPE_PT_ADDBITS14
7337 | OPTS_TYPE_PT_UNICODE;
7338 kern_type = KERN_TYPE_MD4_PWU;
7339 dgst_size = DGST_SIZE_4_4;
7340 parse_func = md4_parse_hash;
7341 sort_by_digest = sort_by_digest_4_4;
7342 opti_type = OPTI_TYPE_ZERO_BYTE
7343 | OPTI_TYPE_PRECOMPUTE_INIT
7344 | OPTI_TYPE_PRECOMPUTE_MERKLE
7345 | OPTI_TYPE_MEET_IN_MIDDLE
7346 | OPTI_TYPE_EARLY_SKIP
7347 | OPTI_TYPE_NOT_ITERATED
7348 | OPTI_TYPE_NOT_SALTED
7349 | OPTI_TYPE_RAW_HASH;
7350 dgst_pos0 = 0;
7351 dgst_pos1 = 3;
7352 dgst_pos2 = 2;
7353 dgst_pos3 = 1;
7354 break;
7355
7356 case 1100: hash_type = HASH_TYPE_MD4;
7357 salt_type = SALT_TYPE_INTERN;
7358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7359 opts_type = OPTS_TYPE_PT_GENERATE_LE
7360 | OPTS_TYPE_PT_ADD80
7361 | OPTS_TYPE_PT_ADDBITS14
7362 | OPTS_TYPE_PT_UNICODE
7363 | OPTS_TYPE_ST_ADD80
7364 | OPTS_TYPE_ST_UNICODE
7365 | OPTS_TYPE_ST_LOWER;
7366 kern_type = KERN_TYPE_MD44_PWUSLT;
7367 dgst_size = DGST_SIZE_4_4;
7368 parse_func = dcc_parse_hash;
7369 sort_by_digest = sort_by_digest_4_4;
7370 opti_type = OPTI_TYPE_ZERO_BYTE
7371 | OPTI_TYPE_PRECOMPUTE_INIT
7372 | OPTI_TYPE_PRECOMPUTE_MERKLE
7373 | OPTI_TYPE_EARLY_SKIP
7374 | OPTI_TYPE_NOT_ITERATED;
7375 dgst_pos0 = 0;
7376 dgst_pos1 = 3;
7377 dgst_pos2 = 2;
7378 dgst_pos3 = 1;
7379 break;
7380
7381 case 1400: hash_type = HASH_TYPE_SHA256;
7382 salt_type = SALT_TYPE_NONE;
7383 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7384 opts_type = OPTS_TYPE_PT_GENERATE_BE
7385 | OPTS_TYPE_PT_ADD80
7386 | OPTS_TYPE_PT_ADDBITS15;
7387 kern_type = KERN_TYPE_SHA256;
7388 dgst_size = DGST_SIZE_4_8;
7389 parse_func = sha256_parse_hash;
7390 sort_by_digest = sort_by_digest_4_8;
7391 opti_type = OPTI_TYPE_ZERO_BYTE
7392 | OPTI_TYPE_PRECOMPUTE_INIT
7393 | OPTI_TYPE_PRECOMPUTE_MERKLE
7394 | OPTI_TYPE_EARLY_SKIP
7395 | OPTI_TYPE_NOT_ITERATED
7396 | OPTI_TYPE_NOT_SALTED
7397 | OPTI_TYPE_RAW_HASH;
7398 dgst_pos0 = 3;
7399 dgst_pos1 = 7;
7400 dgst_pos2 = 2;
7401 dgst_pos3 = 6;
7402 break;
7403
7404 case 1410: hash_type = HASH_TYPE_SHA256;
7405 salt_type = SALT_TYPE_INTERN;
7406 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7407 opts_type = OPTS_TYPE_PT_GENERATE_BE
7408 | OPTS_TYPE_ST_ADD80
7409 | OPTS_TYPE_ST_ADDBITS15;
7410 kern_type = KERN_TYPE_SHA256_PWSLT;
7411 dgst_size = DGST_SIZE_4_8;
7412 parse_func = sha256s_parse_hash;
7413 sort_by_digest = sort_by_digest_4_8;
7414 opti_type = OPTI_TYPE_ZERO_BYTE
7415 | OPTI_TYPE_PRECOMPUTE_INIT
7416 | OPTI_TYPE_PRECOMPUTE_MERKLE
7417 | OPTI_TYPE_EARLY_SKIP
7418 | OPTI_TYPE_NOT_ITERATED
7419 | OPTI_TYPE_APPENDED_SALT
7420 | OPTI_TYPE_RAW_HASH;
7421 dgst_pos0 = 3;
7422 dgst_pos1 = 7;
7423 dgst_pos2 = 2;
7424 dgst_pos3 = 6;
7425 break;
7426
7427 case 1420: hash_type = HASH_TYPE_SHA256;
7428 salt_type = SALT_TYPE_INTERN;
7429 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7430 opts_type = OPTS_TYPE_PT_GENERATE_BE
7431 | OPTS_TYPE_PT_ADD80
7432 | OPTS_TYPE_PT_ADDBITS15;
7433 kern_type = KERN_TYPE_SHA256_SLTPW;
7434 dgst_size = DGST_SIZE_4_8;
7435 parse_func = sha256s_parse_hash;
7436 sort_by_digest = sort_by_digest_4_8;
7437 opti_type = OPTI_TYPE_ZERO_BYTE
7438 | OPTI_TYPE_PRECOMPUTE_INIT
7439 | OPTI_TYPE_PRECOMPUTE_MERKLE
7440 | OPTI_TYPE_EARLY_SKIP
7441 | OPTI_TYPE_NOT_ITERATED
7442 | OPTI_TYPE_PREPENDED_SALT
7443 | OPTI_TYPE_RAW_HASH;
7444 dgst_pos0 = 3;
7445 dgst_pos1 = 7;
7446 dgst_pos2 = 2;
7447 dgst_pos3 = 6;
7448 break;
7449
7450 case 1421: hash_type = HASH_TYPE_SHA256;
7451 salt_type = SALT_TYPE_EMBEDDED;
7452 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7453 opts_type = OPTS_TYPE_PT_GENERATE_BE
7454 | OPTS_TYPE_PT_ADD80
7455 | OPTS_TYPE_PT_ADDBITS15;
7456 kern_type = KERN_TYPE_SHA256_SLTPW;
7457 dgst_size = DGST_SIZE_4_8;
7458 parse_func = hmailserver_parse_hash;
7459 sort_by_digest = sort_by_digest_4_8;
7460 opti_type = OPTI_TYPE_ZERO_BYTE
7461 | OPTI_TYPE_PRECOMPUTE_INIT
7462 | OPTI_TYPE_PRECOMPUTE_MERKLE
7463 | OPTI_TYPE_EARLY_SKIP
7464 | OPTI_TYPE_NOT_ITERATED
7465 | OPTI_TYPE_PREPENDED_SALT
7466 | OPTI_TYPE_RAW_HASH;
7467 dgst_pos0 = 3;
7468 dgst_pos1 = 7;
7469 dgst_pos2 = 2;
7470 dgst_pos3 = 6;
7471 break;
7472
7473 case 1430: hash_type = HASH_TYPE_SHA256;
7474 salt_type = SALT_TYPE_INTERN;
7475 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7476 opts_type = OPTS_TYPE_PT_GENERATE_BE
7477 | OPTS_TYPE_PT_UNICODE
7478 | OPTS_TYPE_ST_ADD80
7479 | OPTS_TYPE_ST_ADDBITS15;
7480 kern_type = KERN_TYPE_SHA256_PWUSLT;
7481 dgst_size = DGST_SIZE_4_8;
7482 parse_func = sha256s_parse_hash;
7483 sort_by_digest = sort_by_digest_4_8;
7484 opti_type = OPTI_TYPE_ZERO_BYTE
7485 | OPTI_TYPE_PRECOMPUTE_INIT
7486 | OPTI_TYPE_PRECOMPUTE_MERKLE
7487 | OPTI_TYPE_EARLY_SKIP
7488 | OPTI_TYPE_NOT_ITERATED
7489 | OPTI_TYPE_APPENDED_SALT
7490 | OPTI_TYPE_RAW_HASH;
7491 dgst_pos0 = 3;
7492 dgst_pos1 = 7;
7493 dgst_pos2 = 2;
7494 dgst_pos3 = 6;
7495 break;
7496
7497 case 1440: hash_type = HASH_TYPE_SHA256;
7498 salt_type = SALT_TYPE_INTERN;
7499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7500 opts_type = OPTS_TYPE_PT_GENERATE_BE
7501 | OPTS_TYPE_PT_ADD80
7502 | OPTS_TYPE_PT_ADDBITS15
7503 | OPTS_TYPE_PT_UNICODE;
7504 kern_type = KERN_TYPE_SHA256_SLTPWU;
7505 dgst_size = DGST_SIZE_4_8;
7506 parse_func = sha256s_parse_hash;
7507 sort_by_digest = sort_by_digest_4_8;
7508 opti_type = OPTI_TYPE_ZERO_BYTE
7509 | OPTI_TYPE_PRECOMPUTE_INIT
7510 | OPTI_TYPE_PRECOMPUTE_MERKLE
7511 | OPTI_TYPE_EARLY_SKIP
7512 | OPTI_TYPE_NOT_ITERATED
7513 | OPTI_TYPE_PREPENDED_SALT
7514 | OPTI_TYPE_RAW_HASH;
7515 dgst_pos0 = 3;
7516 dgst_pos1 = 7;
7517 dgst_pos2 = 2;
7518 dgst_pos3 = 6;
7519 break;
7520
7521 case 1441: hash_type = HASH_TYPE_SHA256;
7522 salt_type = SALT_TYPE_EMBEDDED;
7523 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7524 opts_type = OPTS_TYPE_PT_GENERATE_BE
7525 | OPTS_TYPE_PT_ADD80
7526 | OPTS_TYPE_PT_ADDBITS15
7527 | OPTS_TYPE_PT_UNICODE
7528 | OPTS_TYPE_ST_BASE64;
7529 kern_type = KERN_TYPE_SHA256_SLTPWU;
7530 dgst_size = DGST_SIZE_4_8;
7531 parse_func = episerver4_parse_hash;
7532 sort_by_digest = sort_by_digest_4_8;
7533 opti_type = OPTI_TYPE_ZERO_BYTE
7534 | OPTI_TYPE_PRECOMPUTE_INIT
7535 | OPTI_TYPE_PRECOMPUTE_MERKLE
7536 | OPTI_TYPE_EARLY_SKIP
7537 | OPTI_TYPE_NOT_ITERATED
7538 | OPTI_TYPE_PREPENDED_SALT
7539 | OPTI_TYPE_RAW_HASH;
7540 dgst_pos0 = 3;
7541 dgst_pos1 = 7;
7542 dgst_pos2 = 2;
7543 dgst_pos3 = 6;
7544 break;
7545
7546 case 1450: hash_type = HASH_TYPE_SHA256;
7547 salt_type = SALT_TYPE_INTERN;
7548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7549 opts_type = OPTS_TYPE_PT_GENERATE_BE
7550 | OPTS_TYPE_ST_ADD80;
7551 kern_type = KERN_TYPE_HMACSHA256_PW;
7552 dgst_size = DGST_SIZE_4_8;
7553 parse_func = hmacsha256_parse_hash;
7554 sort_by_digest = sort_by_digest_4_8;
7555 opti_type = OPTI_TYPE_ZERO_BYTE
7556 | OPTI_TYPE_NOT_ITERATED;
7557 dgst_pos0 = 3;
7558 dgst_pos1 = 7;
7559 dgst_pos2 = 2;
7560 dgst_pos3 = 6;
7561 break;
7562
7563 case 1460: hash_type = HASH_TYPE_SHA256;
7564 salt_type = SALT_TYPE_INTERN;
7565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7566 opts_type = OPTS_TYPE_PT_GENERATE_BE
7567 | OPTS_TYPE_PT_ADD80
7568 | OPTS_TYPE_PT_ADDBITS15;
7569 kern_type = KERN_TYPE_HMACSHA256_SLT;
7570 dgst_size = DGST_SIZE_4_8;
7571 parse_func = hmacsha256_parse_hash;
7572 sort_by_digest = sort_by_digest_4_8;
7573 opti_type = OPTI_TYPE_ZERO_BYTE
7574 | OPTI_TYPE_NOT_ITERATED;
7575 dgst_pos0 = 3;
7576 dgst_pos1 = 7;
7577 dgst_pos2 = 2;
7578 dgst_pos3 = 6;
7579 break;
7580
7581 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7582 salt_type = SALT_TYPE_EMBEDDED;
7583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7584 opts_type = OPTS_TYPE_PT_GENERATE_LE
7585 | OPTS_TYPE_PT_BITSLICE;
7586 kern_type = KERN_TYPE_DESCRYPT;
7587 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7588 parse_func = descrypt_parse_hash;
7589 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7590 opti_type = OPTI_TYPE_ZERO_BYTE
7591 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7592 dgst_pos0 = 0;
7593 dgst_pos1 = 1;
7594 dgst_pos2 = 2;
7595 dgst_pos3 = 3;
7596 break;
7597
7598 case 1600: hash_type = HASH_TYPE_MD5;
7599 salt_type = SALT_TYPE_EMBEDDED;
7600 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7601 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7602 kern_type = KERN_TYPE_APR1CRYPT;
7603 dgst_size = DGST_SIZE_4_4;
7604 parse_func = md5apr1_parse_hash;
7605 sort_by_digest = sort_by_digest_4_4;
7606 opti_type = OPTI_TYPE_ZERO_BYTE;
7607 dgst_pos0 = 0;
7608 dgst_pos1 = 1;
7609 dgst_pos2 = 2;
7610 dgst_pos3 = 3;
7611 break;
7612
7613 case 1700: hash_type = HASH_TYPE_SHA512;
7614 salt_type = SALT_TYPE_NONE;
7615 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7616 opts_type = OPTS_TYPE_PT_GENERATE_BE
7617 | OPTS_TYPE_PT_ADD80
7618 | OPTS_TYPE_PT_ADDBITS15;
7619 kern_type = KERN_TYPE_SHA512;
7620 dgst_size = DGST_SIZE_8_8;
7621 parse_func = sha512_parse_hash;
7622 sort_by_digest = sort_by_digest_8_8;
7623 opti_type = OPTI_TYPE_ZERO_BYTE
7624 | OPTI_TYPE_PRECOMPUTE_INIT
7625 | OPTI_TYPE_PRECOMPUTE_MERKLE
7626 | OPTI_TYPE_EARLY_SKIP
7627 | OPTI_TYPE_NOT_ITERATED
7628 | OPTI_TYPE_NOT_SALTED
7629 | OPTI_TYPE_RAW_HASH;
7630 dgst_pos0 = 14;
7631 dgst_pos1 = 15;
7632 dgst_pos2 = 6;
7633 dgst_pos3 = 7;
7634 break;
7635
7636 case 1710: hash_type = HASH_TYPE_SHA512;
7637 salt_type = SALT_TYPE_INTERN;
7638 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7639 opts_type = OPTS_TYPE_PT_GENERATE_BE
7640 | OPTS_TYPE_ST_ADD80
7641 | OPTS_TYPE_ST_ADDBITS15;
7642 kern_type = KERN_TYPE_SHA512_PWSLT;
7643 dgst_size = DGST_SIZE_8_8;
7644 parse_func = sha512s_parse_hash;
7645 sort_by_digest = sort_by_digest_8_8;
7646 opti_type = OPTI_TYPE_ZERO_BYTE
7647 | OPTI_TYPE_PRECOMPUTE_INIT
7648 | OPTI_TYPE_PRECOMPUTE_MERKLE
7649 | OPTI_TYPE_EARLY_SKIP
7650 | OPTI_TYPE_NOT_ITERATED
7651 | OPTI_TYPE_APPENDED_SALT
7652 | OPTI_TYPE_RAW_HASH;
7653 dgst_pos0 = 14;
7654 dgst_pos1 = 15;
7655 dgst_pos2 = 6;
7656 dgst_pos3 = 7;
7657 break;
7658
7659 case 1711: hash_type = HASH_TYPE_SHA512;
7660 salt_type = SALT_TYPE_EMBEDDED;
7661 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7662 opts_type = OPTS_TYPE_PT_GENERATE_BE
7663 | OPTS_TYPE_ST_ADD80
7664 | OPTS_TYPE_ST_ADDBITS15;
7665 kern_type = KERN_TYPE_SHA512_PWSLT;
7666 dgst_size = DGST_SIZE_8_8;
7667 parse_func = sha512b64s_parse_hash;
7668 sort_by_digest = sort_by_digest_8_8;
7669 opti_type = OPTI_TYPE_ZERO_BYTE
7670 | OPTI_TYPE_PRECOMPUTE_INIT
7671 | OPTI_TYPE_PRECOMPUTE_MERKLE
7672 | OPTI_TYPE_EARLY_SKIP
7673 | OPTI_TYPE_NOT_ITERATED
7674 | OPTI_TYPE_APPENDED_SALT
7675 | OPTI_TYPE_RAW_HASH;
7676 dgst_pos0 = 14;
7677 dgst_pos1 = 15;
7678 dgst_pos2 = 6;
7679 dgst_pos3 = 7;
7680 break;
7681
7682 case 1720: hash_type = HASH_TYPE_SHA512;
7683 salt_type = SALT_TYPE_INTERN;
7684 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7685 opts_type = OPTS_TYPE_PT_GENERATE_BE
7686 | OPTS_TYPE_PT_ADD80
7687 | OPTS_TYPE_PT_ADDBITS15;
7688 kern_type = KERN_TYPE_SHA512_SLTPW;
7689 dgst_size = DGST_SIZE_8_8;
7690 parse_func = sha512s_parse_hash;
7691 sort_by_digest = sort_by_digest_8_8;
7692 opti_type = OPTI_TYPE_ZERO_BYTE
7693 | OPTI_TYPE_PRECOMPUTE_INIT
7694 | OPTI_TYPE_PRECOMPUTE_MERKLE
7695 | OPTI_TYPE_EARLY_SKIP
7696 | OPTI_TYPE_NOT_ITERATED
7697 | OPTI_TYPE_PREPENDED_SALT
7698 | OPTI_TYPE_RAW_HASH;
7699 dgst_pos0 = 14;
7700 dgst_pos1 = 15;
7701 dgst_pos2 = 6;
7702 dgst_pos3 = 7;
7703 break;
7704
7705 case 1722: hash_type = HASH_TYPE_SHA512;
7706 salt_type = SALT_TYPE_EMBEDDED;
7707 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7708 opts_type = OPTS_TYPE_PT_GENERATE_BE
7709 | OPTS_TYPE_PT_ADD80
7710 | OPTS_TYPE_PT_ADDBITS15
7711 | OPTS_TYPE_ST_HEX;
7712 kern_type = KERN_TYPE_SHA512_SLTPW;
7713 dgst_size = DGST_SIZE_8_8;
7714 parse_func = osx512_parse_hash;
7715 sort_by_digest = sort_by_digest_8_8;
7716 opti_type = OPTI_TYPE_ZERO_BYTE
7717 | OPTI_TYPE_PRECOMPUTE_INIT
7718 | OPTI_TYPE_PRECOMPUTE_MERKLE
7719 | OPTI_TYPE_EARLY_SKIP
7720 | OPTI_TYPE_NOT_ITERATED
7721 | OPTI_TYPE_PREPENDED_SALT
7722 | OPTI_TYPE_RAW_HASH;
7723 dgst_pos0 = 14;
7724 dgst_pos1 = 15;
7725 dgst_pos2 = 6;
7726 dgst_pos3 = 7;
7727 break;
7728
7729 case 1730: hash_type = HASH_TYPE_SHA512;
7730 salt_type = SALT_TYPE_INTERN;
7731 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7732 opts_type = OPTS_TYPE_PT_GENERATE_BE
7733 | OPTS_TYPE_PT_UNICODE
7734 | OPTS_TYPE_ST_ADD80
7735 | OPTS_TYPE_ST_ADDBITS15;
7736 kern_type = KERN_TYPE_SHA512_PWSLTU;
7737 dgst_size = DGST_SIZE_8_8;
7738 parse_func = sha512s_parse_hash;
7739 sort_by_digest = sort_by_digest_8_8;
7740 opti_type = OPTI_TYPE_ZERO_BYTE
7741 | OPTI_TYPE_PRECOMPUTE_INIT
7742 | OPTI_TYPE_PRECOMPUTE_MERKLE
7743 | OPTI_TYPE_EARLY_SKIP
7744 | OPTI_TYPE_NOT_ITERATED
7745 | OPTI_TYPE_APPENDED_SALT
7746 | OPTI_TYPE_RAW_HASH;
7747 dgst_pos0 = 14;
7748 dgst_pos1 = 15;
7749 dgst_pos2 = 6;
7750 dgst_pos3 = 7;
7751 break;
7752
7753 case 1731: hash_type = HASH_TYPE_SHA512;
7754 salt_type = SALT_TYPE_EMBEDDED;
7755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7756 opts_type = OPTS_TYPE_PT_GENERATE_BE
7757 | OPTS_TYPE_PT_UNICODE
7758 | OPTS_TYPE_ST_ADD80
7759 | OPTS_TYPE_ST_ADDBITS15
7760 | OPTS_TYPE_ST_HEX;
7761 kern_type = KERN_TYPE_SHA512_PWSLTU;
7762 dgst_size = DGST_SIZE_8_8;
7763 parse_func = mssql2012_parse_hash;
7764 sort_by_digest = sort_by_digest_8_8;
7765 opti_type = OPTI_TYPE_ZERO_BYTE
7766 | OPTI_TYPE_PRECOMPUTE_INIT
7767 | OPTI_TYPE_PRECOMPUTE_MERKLE
7768 | OPTI_TYPE_EARLY_SKIP
7769 | OPTI_TYPE_NOT_ITERATED
7770 | OPTI_TYPE_APPENDED_SALT
7771 | OPTI_TYPE_RAW_HASH;
7772 dgst_pos0 = 14;
7773 dgst_pos1 = 15;
7774 dgst_pos2 = 6;
7775 dgst_pos3 = 7;
7776 break;
7777
7778 case 1740: hash_type = HASH_TYPE_SHA512;
7779 salt_type = SALT_TYPE_INTERN;
7780 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7781 opts_type = OPTS_TYPE_PT_GENERATE_BE
7782 | OPTS_TYPE_PT_ADD80
7783 | OPTS_TYPE_PT_ADDBITS15
7784 | OPTS_TYPE_PT_UNICODE;
7785 kern_type = KERN_TYPE_SHA512_SLTPWU;
7786 dgst_size = DGST_SIZE_8_8;
7787 parse_func = sha512s_parse_hash;
7788 sort_by_digest = sort_by_digest_8_8;
7789 opti_type = OPTI_TYPE_ZERO_BYTE
7790 | OPTI_TYPE_PRECOMPUTE_INIT
7791 | OPTI_TYPE_PRECOMPUTE_MERKLE
7792 | OPTI_TYPE_EARLY_SKIP
7793 | OPTI_TYPE_NOT_ITERATED
7794 | OPTI_TYPE_PREPENDED_SALT
7795 | OPTI_TYPE_RAW_HASH;
7796 dgst_pos0 = 14;
7797 dgst_pos1 = 15;
7798 dgst_pos2 = 6;
7799 dgst_pos3 = 7;
7800 break;
7801
7802 case 1750: hash_type = HASH_TYPE_SHA512;
7803 salt_type = SALT_TYPE_INTERN;
7804 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7805 opts_type = OPTS_TYPE_PT_GENERATE_BE
7806 | OPTS_TYPE_ST_ADD80;
7807 kern_type = KERN_TYPE_HMACSHA512_PW;
7808 dgst_size = DGST_SIZE_8_8;
7809 parse_func = hmacsha512_parse_hash;
7810 sort_by_digest = sort_by_digest_8_8;
7811 opti_type = OPTI_TYPE_ZERO_BYTE
7812 | OPTI_TYPE_NOT_ITERATED;
7813 dgst_pos0 = 14;
7814 dgst_pos1 = 15;
7815 dgst_pos2 = 6;
7816 dgst_pos3 = 7;
7817 break;
7818
7819 case 1760: hash_type = HASH_TYPE_SHA512;
7820 salt_type = SALT_TYPE_INTERN;
7821 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7822 opts_type = OPTS_TYPE_PT_GENERATE_BE
7823 | OPTS_TYPE_PT_ADD80
7824 | OPTS_TYPE_PT_ADDBITS15;
7825 kern_type = KERN_TYPE_HMACSHA512_SLT;
7826 dgst_size = DGST_SIZE_8_8;
7827 parse_func = hmacsha512_parse_hash;
7828 sort_by_digest = sort_by_digest_8_8;
7829 opti_type = OPTI_TYPE_ZERO_BYTE
7830 | OPTI_TYPE_NOT_ITERATED;
7831 dgst_pos0 = 14;
7832 dgst_pos1 = 15;
7833 dgst_pos2 = 6;
7834 dgst_pos3 = 7;
7835 break;
7836
7837 case 1800: hash_type = HASH_TYPE_SHA512;
7838 salt_type = SALT_TYPE_EMBEDDED;
7839 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7840 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7841 kern_type = KERN_TYPE_SHA512CRYPT;
7842 dgst_size = DGST_SIZE_8_8;
7843 parse_func = sha512crypt_parse_hash;
7844 sort_by_digest = sort_by_digest_8_8;
7845 opti_type = OPTI_TYPE_ZERO_BYTE;
7846 dgst_pos0 = 0;
7847 dgst_pos1 = 1;
7848 dgst_pos2 = 2;
7849 dgst_pos3 = 3;
7850 break;
7851
7852 case 2100: hash_type = HASH_TYPE_DCC2;
7853 salt_type = SALT_TYPE_EMBEDDED;
7854 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7855 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7856 | OPTS_TYPE_ST_LOWER
7857 | OPTS_TYPE_ST_UNICODE;
7858 kern_type = KERN_TYPE_DCC2;
7859 dgst_size = DGST_SIZE_4_4;
7860 parse_func = dcc2_parse_hash;
7861 sort_by_digest = sort_by_digest_4_4;
7862 opti_type = OPTI_TYPE_ZERO_BYTE;
7863 dgst_pos0 = 0;
7864 dgst_pos1 = 1;
7865 dgst_pos2 = 2;
7866 dgst_pos3 = 3;
7867 break;
7868
7869 case 2400: hash_type = HASH_TYPE_MD5;
7870 salt_type = SALT_TYPE_NONE;
7871 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7872 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7873 kern_type = KERN_TYPE_MD5PIX;
7874 dgst_size = DGST_SIZE_4_4;
7875 parse_func = md5pix_parse_hash;
7876 sort_by_digest = sort_by_digest_4_4;
7877 opti_type = OPTI_TYPE_ZERO_BYTE
7878 | OPTI_TYPE_PRECOMPUTE_INIT
7879 | OPTI_TYPE_PRECOMPUTE_MERKLE
7880 | OPTI_TYPE_EARLY_SKIP
7881 | OPTI_TYPE_NOT_ITERATED
7882 | OPTI_TYPE_NOT_SALTED;
7883 dgst_pos0 = 0;
7884 dgst_pos1 = 3;
7885 dgst_pos2 = 2;
7886 dgst_pos3 = 1;
7887 break;
7888
7889 case 2410: hash_type = HASH_TYPE_MD5;
7890 salt_type = SALT_TYPE_INTERN;
7891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7892 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7893 kern_type = KERN_TYPE_MD5ASA;
7894 dgst_size = DGST_SIZE_4_4;
7895 parse_func = md5asa_parse_hash;
7896 sort_by_digest = sort_by_digest_4_4;
7897 opti_type = OPTI_TYPE_ZERO_BYTE
7898 | OPTI_TYPE_PRECOMPUTE_INIT
7899 | OPTI_TYPE_PRECOMPUTE_MERKLE
7900 | OPTI_TYPE_EARLY_SKIP
7901 | OPTI_TYPE_NOT_ITERATED;
7902 dgst_pos0 = 0;
7903 dgst_pos1 = 3;
7904 dgst_pos2 = 2;
7905 dgst_pos3 = 1;
7906 break;
7907
7908 case 2500: hash_type = HASH_TYPE_WPA;
7909 salt_type = SALT_TYPE_EMBEDDED;
7910 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7911 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7912 kern_type = KERN_TYPE_WPA;
7913 dgst_size = DGST_SIZE_4_4;
7914 parse_func = wpa_parse_hash;
7915 sort_by_digest = sort_by_digest_4_4;
7916 opti_type = OPTI_TYPE_ZERO_BYTE;
7917 dgst_pos0 = 0;
7918 dgst_pos1 = 1;
7919 dgst_pos2 = 2;
7920 dgst_pos3 = 3;
7921 break;
7922
7923 case 2600: hash_type = HASH_TYPE_MD5;
7924 salt_type = SALT_TYPE_VIRTUAL;
7925 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7926 opts_type = OPTS_TYPE_PT_GENERATE_LE
7927 | OPTS_TYPE_PT_ADD80
7928 | OPTS_TYPE_PT_ADDBITS14
7929 | OPTS_TYPE_ST_ADD80;
7930 kern_type = KERN_TYPE_MD55_PWSLT1;
7931 dgst_size = DGST_SIZE_4_4;
7932 parse_func = md5md5_parse_hash;
7933 sort_by_digest = sort_by_digest_4_4;
7934 opti_type = OPTI_TYPE_ZERO_BYTE
7935 | OPTI_TYPE_PRECOMPUTE_INIT
7936 | OPTI_TYPE_PRECOMPUTE_MERKLE
7937 | OPTI_TYPE_EARLY_SKIP;
7938 dgst_pos0 = 0;
7939 dgst_pos1 = 3;
7940 dgst_pos2 = 2;
7941 dgst_pos3 = 1;
7942 break;
7943
7944 case 2611: hash_type = HASH_TYPE_MD5;
7945 salt_type = SALT_TYPE_INTERN;
7946 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7947 opts_type = OPTS_TYPE_PT_GENERATE_LE
7948 | OPTS_TYPE_PT_ADD80
7949 | OPTS_TYPE_PT_ADDBITS14
7950 | OPTS_TYPE_ST_ADD80;
7951 kern_type = KERN_TYPE_MD55_PWSLT1;
7952 dgst_size = DGST_SIZE_4_4;
7953 parse_func = vb3_parse_hash;
7954 sort_by_digest = sort_by_digest_4_4;
7955 opti_type = OPTI_TYPE_ZERO_BYTE
7956 | OPTI_TYPE_PRECOMPUTE_INIT
7957 | OPTI_TYPE_PRECOMPUTE_MERKLE
7958 | OPTI_TYPE_EARLY_SKIP;
7959 dgst_pos0 = 0;
7960 dgst_pos1 = 3;
7961 dgst_pos2 = 2;
7962 dgst_pos3 = 1;
7963 break;
7964
7965 case 2612: hash_type = HASH_TYPE_MD5;
7966 salt_type = SALT_TYPE_EMBEDDED;
7967 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7968 opts_type = OPTS_TYPE_PT_GENERATE_LE
7969 | OPTS_TYPE_PT_ADD80
7970 | OPTS_TYPE_PT_ADDBITS14
7971 | OPTS_TYPE_ST_ADD80
7972 | OPTS_TYPE_ST_HEX;
7973 kern_type = KERN_TYPE_MD55_PWSLT1;
7974 dgst_size = DGST_SIZE_4_4;
7975 parse_func = phps_parse_hash;
7976 sort_by_digest = sort_by_digest_4_4;
7977 opti_type = OPTI_TYPE_ZERO_BYTE
7978 | OPTI_TYPE_PRECOMPUTE_INIT
7979 | OPTI_TYPE_PRECOMPUTE_MERKLE
7980 | OPTI_TYPE_EARLY_SKIP;
7981 dgst_pos0 = 0;
7982 dgst_pos1 = 3;
7983 dgst_pos2 = 2;
7984 dgst_pos3 = 1;
7985 break;
7986
7987 case 2711: hash_type = HASH_TYPE_MD5;
7988 salt_type = SALT_TYPE_INTERN;
7989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7990 opts_type = OPTS_TYPE_PT_GENERATE_LE
7991 | OPTS_TYPE_PT_ADD80
7992 | OPTS_TYPE_PT_ADDBITS14
7993 | OPTS_TYPE_ST_ADD80;
7994 kern_type = KERN_TYPE_MD55_PWSLT2;
7995 dgst_size = DGST_SIZE_4_4;
7996 parse_func = vb30_parse_hash;
7997 sort_by_digest = sort_by_digest_4_4;
7998 opti_type = OPTI_TYPE_ZERO_BYTE
7999 | OPTI_TYPE_PRECOMPUTE_INIT
8000 | OPTI_TYPE_EARLY_SKIP;
8001 dgst_pos0 = 0;
8002 dgst_pos1 = 3;
8003 dgst_pos2 = 2;
8004 dgst_pos3 = 1;
8005 break;
8006
8007 case 2811: hash_type = HASH_TYPE_MD5;
8008 salt_type = SALT_TYPE_INTERN;
8009 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8010 opts_type = OPTS_TYPE_PT_GENERATE_LE
8011 | OPTS_TYPE_PT_ADD80
8012 | OPTS_TYPE_PT_ADDBITS14;
8013 kern_type = KERN_TYPE_MD55_SLTPW;
8014 dgst_size = DGST_SIZE_4_4;
8015 parse_func = ipb2_parse_hash;
8016 sort_by_digest = sort_by_digest_4_4;
8017 opti_type = OPTI_TYPE_ZERO_BYTE
8018 | OPTI_TYPE_PRECOMPUTE_INIT
8019 | OPTI_TYPE_EARLY_SKIP;
8020 dgst_pos0 = 0;
8021 dgst_pos1 = 3;
8022 dgst_pos2 = 2;
8023 dgst_pos3 = 1;
8024 break;
8025
8026 case 3000: hash_type = HASH_TYPE_LM;
8027 salt_type = SALT_TYPE_NONE;
8028 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8029 opts_type = OPTS_TYPE_PT_GENERATE_LE
8030 | OPTS_TYPE_PT_UPPER
8031 | OPTS_TYPE_PT_BITSLICE;
8032 kern_type = KERN_TYPE_LM;
8033 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8034 parse_func = lm_parse_hash;
8035 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8036 opti_type = OPTI_TYPE_ZERO_BYTE
8037 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8038 dgst_pos0 = 0;
8039 dgst_pos1 = 1;
8040 dgst_pos2 = 2;
8041 dgst_pos3 = 3;
8042 break;
8043
8044 case 3100: hash_type = HASH_TYPE_ORACLEH;
8045 salt_type = SALT_TYPE_INTERN;
8046 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8047 opts_type = OPTS_TYPE_PT_GENERATE_LE
8048 | OPTS_TYPE_PT_UPPER
8049 | OPTS_TYPE_ST_UPPER;
8050 kern_type = KERN_TYPE_ORACLEH;
8051 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8052 parse_func = oracleh_parse_hash;
8053 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8054 opti_type = OPTI_TYPE_ZERO_BYTE;
8055 dgst_pos0 = 0;
8056 dgst_pos1 = 1;
8057 dgst_pos2 = 2;
8058 dgst_pos3 = 3;
8059 break;
8060
8061 case 3200: hash_type = HASH_TYPE_BCRYPT;
8062 salt_type = SALT_TYPE_EMBEDDED;
8063 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8064 opts_type = OPTS_TYPE_PT_GENERATE_LE
8065 | OPTS_TYPE_ST_GENERATE_LE;
8066 kern_type = KERN_TYPE_BCRYPT;
8067 dgst_size = DGST_SIZE_4_6;
8068 parse_func = bcrypt_parse_hash;
8069 sort_by_digest = sort_by_digest_4_6;
8070 opti_type = OPTI_TYPE_ZERO_BYTE;
8071 dgst_pos0 = 0;
8072 dgst_pos1 = 1;
8073 dgst_pos2 = 2;
8074 dgst_pos3 = 3;
8075 break;
8076
8077 case 3710: hash_type = HASH_TYPE_MD5;
8078 salt_type = SALT_TYPE_INTERN;
8079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8080 opts_type = OPTS_TYPE_PT_GENERATE_LE
8081 | OPTS_TYPE_PT_ADD80
8082 | OPTS_TYPE_PT_ADDBITS14;
8083 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8084 dgst_size = DGST_SIZE_4_4;
8085 parse_func = md5s_parse_hash;
8086 sort_by_digest = sort_by_digest_4_4;
8087 opti_type = OPTI_TYPE_ZERO_BYTE
8088 | OPTI_TYPE_PRECOMPUTE_INIT
8089 | OPTI_TYPE_PRECOMPUTE_MERKLE
8090 | OPTI_TYPE_EARLY_SKIP;
8091 dgst_pos0 = 0;
8092 dgst_pos1 = 3;
8093 dgst_pos2 = 2;
8094 dgst_pos3 = 1;
8095 break;
8096
8097 case 3711: hash_type = HASH_TYPE_MD5;
8098 salt_type = SALT_TYPE_EMBEDDED;
8099 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8100 opts_type = OPTS_TYPE_PT_GENERATE_LE
8101 | OPTS_TYPE_PT_ADD80
8102 | OPTS_TYPE_PT_ADDBITS14;
8103 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8104 dgst_size = DGST_SIZE_4_4;
8105 parse_func = mediawiki_b_parse_hash;
8106 sort_by_digest = sort_by_digest_4_4;
8107 opti_type = OPTI_TYPE_ZERO_BYTE
8108 | OPTI_TYPE_PRECOMPUTE_INIT
8109 | OPTI_TYPE_PRECOMPUTE_MERKLE
8110 | OPTI_TYPE_EARLY_SKIP;
8111 dgst_pos0 = 0;
8112 dgst_pos1 = 3;
8113 dgst_pos2 = 2;
8114 dgst_pos3 = 1;
8115 break;
8116
8117 case 3800: hash_type = HASH_TYPE_MD5;
8118 salt_type = SALT_TYPE_INTERN;
8119 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8120 opts_type = OPTS_TYPE_PT_GENERATE_LE
8121 | OPTS_TYPE_ST_ADDBITS14;
8122 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8123 dgst_size = DGST_SIZE_4_4;
8124 parse_func = md5s_parse_hash;
8125 sort_by_digest = sort_by_digest_4_4;
8126 opti_type = OPTI_TYPE_ZERO_BYTE
8127 | OPTI_TYPE_PRECOMPUTE_INIT
8128 | OPTI_TYPE_PRECOMPUTE_MERKLE
8129 | OPTI_TYPE_EARLY_SKIP
8130 | OPTI_TYPE_NOT_ITERATED
8131 | OPTI_TYPE_RAW_HASH;
8132 dgst_pos0 = 0;
8133 dgst_pos1 = 3;
8134 dgst_pos2 = 2;
8135 dgst_pos3 = 1;
8136 break;
8137
8138 case 4300: hash_type = HASH_TYPE_MD5;
8139 salt_type = SALT_TYPE_VIRTUAL;
8140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8141 opts_type = OPTS_TYPE_PT_GENERATE_LE
8142 | OPTS_TYPE_PT_ADD80
8143 | OPTS_TYPE_PT_ADDBITS14
8144 | OPTS_TYPE_ST_ADD80;
8145 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8146 dgst_size = DGST_SIZE_4_4;
8147 parse_func = md5md5_parse_hash;
8148 sort_by_digest = sort_by_digest_4_4;
8149 opti_type = OPTI_TYPE_ZERO_BYTE
8150 | OPTI_TYPE_PRECOMPUTE_INIT
8151 | OPTI_TYPE_PRECOMPUTE_MERKLE
8152 | OPTI_TYPE_EARLY_SKIP;
8153 dgst_pos0 = 0;
8154 dgst_pos1 = 3;
8155 dgst_pos2 = 2;
8156 dgst_pos3 = 1;
8157 break;
8158
8159
8160 case 4400: hash_type = HASH_TYPE_MD5;
8161 salt_type = SALT_TYPE_NONE;
8162 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8163 opts_type = OPTS_TYPE_PT_GENERATE_BE
8164 | OPTS_TYPE_PT_ADD80
8165 | OPTS_TYPE_PT_ADDBITS15;
8166 kern_type = KERN_TYPE_MD5_SHA1;
8167 dgst_size = DGST_SIZE_4_4;
8168 parse_func = md5_parse_hash;
8169 sort_by_digest = sort_by_digest_4_4;
8170 opti_type = OPTI_TYPE_ZERO_BYTE
8171 | OPTI_TYPE_PRECOMPUTE_INIT
8172 | OPTI_TYPE_PRECOMPUTE_MERKLE
8173 | OPTI_TYPE_EARLY_SKIP
8174 | OPTI_TYPE_NOT_ITERATED
8175 | OPTI_TYPE_NOT_SALTED
8176 | OPTI_TYPE_RAW_HASH;
8177 dgst_pos0 = 0;
8178 dgst_pos1 = 3;
8179 dgst_pos2 = 2;
8180 dgst_pos3 = 1;
8181 break;
8182
8183 case 4500: hash_type = HASH_TYPE_SHA1;
8184 salt_type = SALT_TYPE_NONE;
8185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8186 opts_type = OPTS_TYPE_PT_GENERATE_BE
8187 | OPTS_TYPE_PT_ADD80
8188 | OPTS_TYPE_PT_ADDBITS15;
8189 kern_type = KERN_TYPE_SHA11;
8190 dgst_size = DGST_SIZE_4_5;
8191 parse_func = sha1_parse_hash;
8192 sort_by_digest = sort_by_digest_4_5;
8193 opti_type = OPTI_TYPE_ZERO_BYTE
8194 | OPTI_TYPE_PRECOMPUTE_INIT
8195 | OPTI_TYPE_PRECOMPUTE_MERKLE
8196 | OPTI_TYPE_EARLY_SKIP
8197 | OPTI_TYPE_NOT_SALTED;
8198 dgst_pos0 = 3;
8199 dgst_pos1 = 4;
8200 dgst_pos2 = 2;
8201 dgst_pos3 = 1;
8202 break;
8203
8204 case 4700: hash_type = HASH_TYPE_SHA1;
8205 salt_type = SALT_TYPE_NONE;
8206 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8207 opts_type = OPTS_TYPE_PT_GENERATE_LE
8208 | OPTS_TYPE_PT_ADD80
8209 | OPTS_TYPE_PT_ADDBITS14;
8210 kern_type = KERN_TYPE_SHA1_MD5;
8211 dgst_size = DGST_SIZE_4_5;
8212 parse_func = sha1_parse_hash;
8213 sort_by_digest = sort_by_digest_4_5;
8214 opti_type = OPTI_TYPE_ZERO_BYTE
8215 | OPTI_TYPE_PRECOMPUTE_INIT
8216 | OPTI_TYPE_PRECOMPUTE_MERKLE
8217 | OPTI_TYPE_EARLY_SKIP
8218 | OPTI_TYPE_NOT_ITERATED
8219 | OPTI_TYPE_NOT_SALTED
8220 | OPTI_TYPE_RAW_HASH;
8221 dgst_pos0 = 3;
8222 dgst_pos1 = 4;
8223 dgst_pos2 = 2;
8224 dgst_pos3 = 1;
8225 break;
8226
8227 case 4800: hash_type = HASH_TYPE_MD5;
8228 salt_type = SALT_TYPE_EMBEDDED;
8229 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8230 opts_type = OPTS_TYPE_PT_GENERATE_LE
8231 | OPTS_TYPE_PT_ADDBITS14;
8232 kern_type = KERN_TYPE_MD5_CHAP;
8233 dgst_size = DGST_SIZE_4_4;
8234 parse_func = chap_parse_hash;
8235 sort_by_digest = sort_by_digest_4_4;
8236 opti_type = OPTI_TYPE_ZERO_BYTE
8237 | OPTI_TYPE_PRECOMPUTE_INIT
8238 | OPTI_TYPE_PRECOMPUTE_MERKLE
8239 | OPTI_TYPE_MEET_IN_MIDDLE
8240 | OPTI_TYPE_EARLY_SKIP
8241 | OPTI_TYPE_NOT_ITERATED
8242 | OPTI_TYPE_RAW_HASH;
8243 dgst_pos0 = 0;
8244 dgst_pos1 = 3;
8245 dgst_pos2 = 2;
8246 dgst_pos3 = 1;
8247 break;
8248
8249 case 4900: hash_type = HASH_TYPE_SHA1;
8250 salt_type = SALT_TYPE_INTERN;
8251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8252 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8253 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8254 dgst_size = DGST_SIZE_4_5;
8255 parse_func = sha1s_parse_hash;
8256 sort_by_digest = sort_by_digest_4_5;
8257 opti_type = OPTI_TYPE_ZERO_BYTE
8258 | OPTI_TYPE_PRECOMPUTE_INIT
8259 | OPTI_TYPE_PRECOMPUTE_MERKLE
8260 | OPTI_TYPE_EARLY_SKIP;
8261 dgst_pos0 = 3;
8262 dgst_pos1 = 4;
8263 dgst_pos2 = 2;
8264 dgst_pos3 = 1;
8265 break;
8266
8267 case 5000: hash_type = HASH_TYPE_KECCAK;
8268 salt_type = SALT_TYPE_EMBEDDED;
8269 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8270 opts_type = OPTS_TYPE_PT_GENERATE_LE
8271 | OPTS_TYPE_PT_ADD01;
8272 kern_type = KERN_TYPE_KECCAK;
8273 dgst_size = DGST_SIZE_8_25;
8274 parse_func = keccak_parse_hash;
8275 sort_by_digest = sort_by_digest_8_25;
8276 opti_type = OPTI_TYPE_ZERO_BYTE
8277 | OPTI_TYPE_RAW_HASH;
8278 dgst_pos0 = 2;
8279 dgst_pos1 = 3;
8280 dgst_pos2 = 4;
8281 dgst_pos3 = 5;
8282 break;
8283
8284 case 5100: hash_type = HASH_TYPE_MD5H;
8285 salt_type = SALT_TYPE_NONE;
8286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8287 opts_type = OPTS_TYPE_PT_GENERATE_LE
8288 | OPTS_TYPE_PT_ADD80
8289 | OPTS_TYPE_PT_ADDBITS14;
8290 kern_type = KERN_TYPE_MD5H;
8291 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8292 parse_func = md5half_parse_hash;
8293 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8294 opti_type = OPTI_TYPE_ZERO_BYTE
8295 | OPTI_TYPE_RAW_HASH;
8296 dgst_pos0 = 0;
8297 dgst_pos1 = 1;
8298 dgst_pos2 = 2;
8299 dgst_pos3 = 3;
8300 break;
8301
8302 case 5200: hash_type = HASH_TYPE_SHA256;
8303 salt_type = SALT_TYPE_EMBEDDED;
8304 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8305 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8306 kern_type = KERN_TYPE_PSAFE3;
8307 dgst_size = DGST_SIZE_4_8;
8308 parse_func = psafe3_parse_hash;
8309 sort_by_digest = sort_by_digest_4_8;
8310 opti_type = OPTI_TYPE_ZERO_BYTE;
8311 dgst_pos0 = 0;
8312 dgst_pos1 = 1;
8313 dgst_pos2 = 2;
8314 dgst_pos3 = 3;
8315 break;
8316
8317 case 5300: hash_type = HASH_TYPE_MD5;
8318 salt_type = SALT_TYPE_EMBEDDED;
8319 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8320 opts_type = OPTS_TYPE_PT_GENERATE_LE
8321 | OPTS_TYPE_ST_ADD80;
8322 kern_type = KERN_TYPE_IKEPSK_MD5;
8323 dgst_size = DGST_SIZE_4_4;
8324 parse_func = ikepsk_md5_parse_hash;
8325 sort_by_digest = sort_by_digest_4_4;
8326 opti_type = OPTI_TYPE_ZERO_BYTE;
8327 dgst_pos0 = 0;
8328 dgst_pos1 = 3;
8329 dgst_pos2 = 2;
8330 dgst_pos3 = 1;
8331 break;
8332
8333 case 5400: hash_type = HASH_TYPE_SHA1;
8334 salt_type = SALT_TYPE_EMBEDDED;
8335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8336 opts_type = OPTS_TYPE_PT_GENERATE_BE
8337 | OPTS_TYPE_ST_ADD80;
8338 kern_type = KERN_TYPE_IKEPSK_SHA1;
8339 dgst_size = DGST_SIZE_4_5;
8340 parse_func = ikepsk_sha1_parse_hash;
8341 sort_by_digest = sort_by_digest_4_5;
8342 opti_type = OPTI_TYPE_ZERO_BYTE;
8343 dgst_pos0 = 3;
8344 dgst_pos1 = 4;
8345 dgst_pos2 = 2;
8346 dgst_pos3 = 1;
8347 break;
8348
8349 case 5500: hash_type = HASH_TYPE_NETNTLM;
8350 salt_type = SALT_TYPE_EMBEDDED;
8351 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8352 opts_type = OPTS_TYPE_PT_GENERATE_LE
8353 | OPTS_TYPE_PT_ADD80
8354 | OPTS_TYPE_PT_ADDBITS14
8355 | OPTS_TYPE_PT_UNICODE
8356 | OPTS_TYPE_ST_HEX;
8357 kern_type = KERN_TYPE_NETNTLMv1;
8358 dgst_size = DGST_SIZE_4_4;
8359 parse_func = netntlmv1_parse_hash;
8360 sort_by_digest = sort_by_digest_4_4;
8361 opti_type = OPTI_TYPE_ZERO_BYTE
8362 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8363 dgst_pos0 = 0;
8364 dgst_pos1 = 1;
8365 dgst_pos2 = 2;
8366 dgst_pos3 = 3;
8367 break;
8368
8369 case 5600: hash_type = HASH_TYPE_MD5;
8370 salt_type = SALT_TYPE_EMBEDDED;
8371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8372 opts_type = OPTS_TYPE_PT_GENERATE_LE
8373 | OPTS_TYPE_PT_ADD80
8374 | OPTS_TYPE_PT_ADDBITS14
8375 | OPTS_TYPE_PT_UNICODE;
8376 kern_type = KERN_TYPE_NETNTLMv2;
8377 dgst_size = DGST_SIZE_4_4;
8378 parse_func = netntlmv2_parse_hash;
8379 sort_by_digest = sort_by_digest_4_4;
8380 opti_type = OPTI_TYPE_ZERO_BYTE;
8381 dgst_pos0 = 0;
8382 dgst_pos1 = 3;
8383 dgst_pos2 = 2;
8384 dgst_pos3 = 1;
8385 break;
8386
8387 case 5700: hash_type = HASH_TYPE_SHA256;
8388 salt_type = SALT_TYPE_NONE;
8389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8390 opts_type = OPTS_TYPE_PT_GENERATE_BE
8391 | OPTS_TYPE_PT_ADD80
8392 | OPTS_TYPE_PT_ADDBITS15;
8393 kern_type = KERN_TYPE_SHA256;
8394 dgst_size = DGST_SIZE_4_8;
8395 parse_func = cisco4_parse_hash;
8396 sort_by_digest = sort_by_digest_4_8;
8397 opti_type = OPTI_TYPE_ZERO_BYTE
8398 | OPTI_TYPE_PRECOMPUTE_INIT
8399 | OPTI_TYPE_PRECOMPUTE_MERKLE
8400 | OPTI_TYPE_EARLY_SKIP
8401 | OPTI_TYPE_NOT_ITERATED
8402 | OPTI_TYPE_NOT_SALTED
8403 | OPTI_TYPE_RAW_HASH;
8404 dgst_pos0 = 3;
8405 dgst_pos1 = 7;
8406 dgst_pos2 = 2;
8407 dgst_pos3 = 6;
8408 break;
8409
8410 case 5800: hash_type = HASH_TYPE_SHA1;
8411 salt_type = SALT_TYPE_INTERN;
8412 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8413 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8414 | OPTS_TYPE_ST_ADD80;
8415 kern_type = KERN_TYPE_ANDROIDPIN;
8416 dgst_size = DGST_SIZE_4_5;
8417 parse_func = androidpin_parse_hash;
8418 sort_by_digest = sort_by_digest_4_5;
8419 opti_type = OPTI_TYPE_ZERO_BYTE;
8420 dgst_pos0 = 0;
8421 dgst_pos1 = 1;
8422 dgst_pos2 = 2;
8423 dgst_pos3 = 3;
8424 break;
8425
8426 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8427 salt_type = SALT_TYPE_NONE;
8428 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8429 opts_type = OPTS_TYPE_PT_GENERATE_LE
8430 | OPTS_TYPE_PT_ADD80;
8431 kern_type = KERN_TYPE_RIPEMD160;
8432 dgst_size = DGST_SIZE_4_5;
8433 parse_func = ripemd160_parse_hash;
8434 sort_by_digest = sort_by_digest_4_5;
8435 opti_type = OPTI_TYPE_ZERO_BYTE;
8436 dgst_pos0 = 0;
8437 dgst_pos1 = 1;
8438 dgst_pos2 = 2;
8439 dgst_pos3 = 3;
8440 break;
8441
8442 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8443 salt_type = SALT_TYPE_NONE;
8444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8445 opts_type = OPTS_TYPE_PT_GENERATE_BE
8446 | OPTS_TYPE_PT_ADD80;
8447 kern_type = KERN_TYPE_WHIRLPOOL;
8448 dgst_size = DGST_SIZE_4_16;
8449 parse_func = whirlpool_parse_hash;
8450 sort_by_digest = sort_by_digest_4_16;
8451 opti_type = OPTI_TYPE_ZERO_BYTE;
8452 dgst_pos0 = 0;
8453 dgst_pos1 = 1;
8454 dgst_pos2 = 2;
8455 dgst_pos3 = 3;
8456 break;
8457
8458 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8459 salt_type = SALT_TYPE_EMBEDDED;
8460 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8461 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8462 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8463 dgst_size = DGST_SIZE_4_5;
8464 parse_func = truecrypt_parse_hash_2k;
8465 sort_by_digest = sort_by_digest_4_5;
8466 opti_type = OPTI_TYPE_ZERO_BYTE;
8467 dgst_pos0 = 0;
8468 dgst_pos1 = 1;
8469 dgst_pos2 = 2;
8470 dgst_pos3 = 3;
8471 break;
8472
8473 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8474 salt_type = SALT_TYPE_EMBEDDED;
8475 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8476 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8477 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8478 dgst_size = DGST_SIZE_4_5;
8479 parse_func = truecrypt_parse_hash_2k;
8480 sort_by_digest = sort_by_digest_4_5;
8481 opti_type = OPTI_TYPE_ZERO_BYTE;
8482 dgst_pos0 = 0;
8483 dgst_pos1 = 1;
8484 dgst_pos2 = 2;
8485 dgst_pos3 = 3;
8486 break;
8487
8488 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8489 salt_type = SALT_TYPE_EMBEDDED;
8490 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8491 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8492 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8493 dgst_size = DGST_SIZE_4_5;
8494 parse_func = truecrypt_parse_hash_2k;
8495 sort_by_digest = sort_by_digest_4_5;
8496 opti_type = OPTI_TYPE_ZERO_BYTE;
8497 dgst_pos0 = 0;
8498 dgst_pos1 = 1;
8499 dgst_pos2 = 2;
8500 dgst_pos3 = 3;
8501 break;
8502
8503 case 6221: hash_type = HASH_TYPE_SHA512;
8504 salt_type = SALT_TYPE_EMBEDDED;
8505 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8506 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8507 kern_type = KERN_TYPE_TCSHA512_XTS512;
8508 dgst_size = DGST_SIZE_8_8;
8509 parse_func = truecrypt_parse_hash_1k;
8510 sort_by_digest = sort_by_digest_8_8;
8511 opti_type = OPTI_TYPE_ZERO_BYTE;
8512 dgst_pos0 = 0;
8513 dgst_pos1 = 1;
8514 dgst_pos2 = 2;
8515 dgst_pos3 = 3;
8516 break;
8517
8518 case 6222: hash_type = HASH_TYPE_SHA512;
8519 salt_type = SALT_TYPE_EMBEDDED;
8520 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8521 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8522 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8523 dgst_size = DGST_SIZE_8_8;
8524 parse_func = truecrypt_parse_hash_1k;
8525 sort_by_digest = sort_by_digest_8_8;
8526 opti_type = OPTI_TYPE_ZERO_BYTE;
8527 dgst_pos0 = 0;
8528 dgst_pos1 = 1;
8529 dgst_pos2 = 2;
8530 dgst_pos3 = 3;
8531 break;
8532
8533 case 6223: hash_type = HASH_TYPE_SHA512;
8534 salt_type = SALT_TYPE_EMBEDDED;
8535 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8536 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8537 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8538 dgst_size = DGST_SIZE_8_8;
8539 parse_func = truecrypt_parse_hash_1k;
8540 sort_by_digest = sort_by_digest_8_8;
8541 opti_type = OPTI_TYPE_ZERO_BYTE;
8542 dgst_pos0 = 0;
8543 dgst_pos1 = 1;
8544 dgst_pos2 = 2;
8545 dgst_pos3 = 3;
8546 break;
8547
8548 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8549 salt_type = SALT_TYPE_EMBEDDED;
8550 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8551 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8552 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8553 dgst_size = DGST_SIZE_4_8;
8554 parse_func = truecrypt_parse_hash_1k;
8555 sort_by_digest = sort_by_digest_4_8;
8556 opti_type = OPTI_TYPE_ZERO_BYTE;
8557 dgst_pos0 = 0;
8558 dgst_pos1 = 1;
8559 dgst_pos2 = 2;
8560 dgst_pos3 = 3;
8561 break;
8562
8563 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8564 salt_type = SALT_TYPE_EMBEDDED;
8565 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8566 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8567 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8568 dgst_size = DGST_SIZE_4_8;
8569 parse_func = truecrypt_parse_hash_1k;
8570 sort_by_digest = sort_by_digest_4_8;
8571 opti_type = OPTI_TYPE_ZERO_BYTE;
8572 dgst_pos0 = 0;
8573 dgst_pos1 = 1;
8574 dgst_pos2 = 2;
8575 dgst_pos3 = 3;
8576 break;
8577
8578 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8579 salt_type = SALT_TYPE_EMBEDDED;
8580 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8581 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8582 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8583 dgst_size = DGST_SIZE_4_8;
8584 parse_func = truecrypt_parse_hash_1k;
8585 sort_by_digest = sort_by_digest_4_8;
8586 opti_type = OPTI_TYPE_ZERO_BYTE;
8587 dgst_pos0 = 0;
8588 dgst_pos1 = 1;
8589 dgst_pos2 = 2;
8590 dgst_pos3 = 3;
8591 break;
8592
8593 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8594 salt_type = SALT_TYPE_EMBEDDED;
8595 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8596 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8597 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8598 dgst_size = DGST_SIZE_4_5;
8599 parse_func = truecrypt_parse_hash_1k;
8600 sort_by_digest = sort_by_digest_4_5;
8601 opti_type = OPTI_TYPE_ZERO_BYTE;
8602 dgst_pos0 = 0;
8603 dgst_pos1 = 1;
8604 dgst_pos2 = 2;
8605 dgst_pos3 = 3;
8606 break;
8607
8608 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8609 salt_type = SALT_TYPE_EMBEDDED;
8610 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8611 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8612 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8613 dgst_size = DGST_SIZE_4_5;
8614 parse_func = truecrypt_parse_hash_1k;
8615 sort_by_digest = sort_by_digest_4_5;
8616 opti_type = OPTI_TYPE_ZERO_BYTE;
8617 dgst_pos0 = 0;
8618 dgst_pos1 = 1;
8619 dgst_pos2 = 2;
8620 dgst_pos3 = 3;
8621 break;
8622
8623 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8624 salt_type = SALT_TYPE_EMBEDDED;
8625 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8626 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8627 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8628 dgst_size = DGST_SIZE_4_5;
8629 parse_func = truecrypt_parse_hash_1k;
8630 sort_by_digest = sort_by_digest_4_5;
8631 opti_type = OPTI_TYPE_ZERO_BYTE;
8632 dgst_pos0 = 0;
8633 dgst_pos1 = 1;
8634 dgst_pos2 = 2;
8635 dgst_pos3 = 3;
8636 break;
8637
8638 case 6300: hash_type = HASH_TYPE_MD5;
8639 salt_type = SALT_TYPE_EMBEDDED;
8640 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8641 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8642 kern_type = KERN_TYPE_MD5AIX;
8643 dgst_size = DGST_SIZE_4_4;
8644 parse_func = md5aix_parse_hash;
8645 sort_by_digest = sort_by_digest_4_4;
8646 opti_type = OPTI_TYPE_ZERO_BYTE;
8647 dgst_pos0 = 0;
8648 dgst_pos1 = 1;
8649 dgst_pos2 = 2;
8650 dgst_pos3 = 3;
8651 break;
8652
8653 case 6400: hash_type = HASH_TYPE_SHA256;
8654 salt_type = SALT_TYPE_EMBEDDED;
8655 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8656 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8657 kern_type = KERN_TYPE_SHA256AIX;
8658 dgst_size = DGST_SIZE_4_8;
8659 parse_func = sha256aix_parse_hash;
8660 sort_by_digest = sort_by_digest_4_8;
8661 opti_type = OPTI_TYPE_ZERO_BYTE;
8662 dgst_pos0 = 0;
8663 dgst_pos1 = 1;
8664 dgst_pos2 = 2;
8665 dgst_pos3 = 3;
8666 break;
8667
8668 case 6500: hash_type = HASH_TYPE_SHA512;
8669 salt_type = SALT_TYPE_EMBEDDED;
8670 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8671 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8672 kern_type = KERN_TYPE_SHA512AIX;
8673 dgst_size = DGST_SIZE_8_8;
8674 parse_func = sha512aix_parse_hash;
8675 sort_by_digest = sort_by_digest_8_8;
8676 opti_type = OPTI_TYPE_ZERO_BYTE;
8677 dgst_pos0 = 0;
8678 dgst_pos1 = 1;
8679 dgst_pos2 = 2;
8680 dgst_pos3 = 3;
8681 break;
8682
8683 case 6600: hash_type = HASH_TYPE_AES;
8684 salt_type = SALT_TYPE_EMBEDDED;
8685 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8686 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8687 kern_type = KERN_TYPE_AGILEKEY;
8688 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8689 parse_func = agilekey_parse_hash;
8690 sort_by_digest = sort_by_digest_4_5;
8691 opti_type = OPTI_TYPE_ZERO_BYTE;
8692 dgst_pos0 = 0;
8693 dgst_pos1 = 1;
8694 dgst_pos2 = 2;
8695 dgst_pos3 = 3;
8696 break;
8697
8698 case 6700: hash_type = HASH_TYPE_SHA1;
8699 salt_type = SALT_TYPE_EMBEDDED;
8700 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8701 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8702 kern_type = KERN_TYPE_SHA1AIX;
8703 dgst_size = DGST_SIZE_4_5;
8704 parse_func = sha1aix_parse_hash;
8705 sort_by_digest = sort_by_digest_4_5;
8706 opti_type = OPTI_TYPE_ZERO_BYTE;
8707 dgst_pos0 = 0;
8708 dgst_pos1 = 1;
8709 dgst_pos2 = 2;
8710 dgst_pos3 = 3;
8711 break;
8712
8713 case 6800: hash_type = HASH_TYPE_AES;
8714 salt_type = SALT_TYPE_EMBEDDED;
8715 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8716 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8717 kern_type = KERN_TYPE_LASTPASS;
8718 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8719 parse_func = lastpass_parse_hash;
8720 sort_by_digest = sort_by_digest_4_8;
8721 opti_type = OPTI_TYPE_ZERO_BYTE;
8722 dgst_pos0 = 0;
8723 dgst_pos1 = 1;
8724 dgst_pos2 = 2;
8725 dgst_pos3 = 3;
8726 break;
8727
8728 case 6900: hash_type = HASH_TYPE_GOST;
8729 salt_type = SALT_TYPE_NONE;
8730 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8731 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8732 kern_type = KERN_TYPE_GOST;
8733 dgst_size = DGST_SIZE_4_8;
8734 parse_func = gost_parse_hash;
8735 sort_by_digest = sort_by_digest_4_8;
8736 opti_type = OPTI_TYPE_ZERO_BYTE;
8737 dgst_pos0 = 0;
8738 dgst_pos1 = 1;
8739 dgst_pos2 = 2;
8740 dgst_pos3 = 3;
8741 break;
8742
8743 case 7100: hash_type = HASH_TYPE_SHA512;
8744 salt_type = SALT_TYPE_EMBEDDED;
8745 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8746 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8747 kern_type = KERN_TYPE_PBKDF2_SHA512;
8748 dgst_size = DGST_SIZE_8_16;
8749 parse_func = sha512osx_parse_hash;
8750 sort_by_digest = sort_by_digest_8_16;
8751 opti_type = OPTI_TYPE_ZERO_BYTE;
8752 dgst_pos0 = 0;
8753 dgst_pos1 = 1;
8754 dgst_pos2 = 2;
8755 dgst_pos3 = 3;
8756 break;
8757
8758 case 7200: hash_type = HASH_TYPE_SHA512;
8759 salt_type = SALT_TYPE_EMBEDDED;
8760 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8761 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8762 kern_type = KERN_TYPE_PBKDF2_SHA512;
8763 dgst_size = DGST_SIZE_8_16;
8764 parse_func = sha512grub_parse_hash;
8765 sort_by_digest = sort_by_digest_8_16;
8766 opti_type = OPTI_TYPE_ZERO_BYTE;
8767 dgst_pos0 = 0;
8768 dgst_pos1 = 1;
8769 dgst_pos2 = 2;
8770 dgst_pos3 = 3;
8771 break;
8772
8773 case 7300: hash_type = HASH_TYPE_SHA1;
8774 salt_type = SALT_TYPE_EMBEDDED;
8775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8776 opts_type = OPTS_TYPE_PT_GENERATE_BE
8777 | OPTS_TYPE_ST_ADD80
8778 | OPTS_TYPE_ST_ADDBITS15;
8779 kern_type = KERN_TYPE_RAKP;
8780 dgst_size = DGST_SIZE_4_5;
8781 parse_func = rakp_parse_hash;
8782 sort_by_digest = sort_by_digest_4_5;
8783 opti_type = OPTI_TYPE_ZERO_BYTE
8784 | OPTI_TYPE_NOT_ITERATED;
8785 dgst_pos0 = 3;
8786 dgst_pos1 = 4;
8787 dgst_pos2 = 2;
8788 dgst_pos3 = 1;
8789 break;
8790
8791 case 7400: hash_type = HASH_TYPE_SHA256;
8792 salt_type = SALT_TYPE_EMBEDDED;
8793 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8794 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8795 kern_type = KERN_TYPE_SHA256CRYPT;
8796 dgst_size = DGST_SIZE_4_8;
8797 parse_func = sha256crypt_parse_hash;
8798 sort_by_digest = sort_by_digest_4_8;
8799 opti_type = OPTI_TYPE_ZERO_BYTE;
8800 dgst_pos0 = 0;
8801 dgst_pos1 = 1;
8802 dgst_pos2 = 2;
8803 dgst_pos3 = 3;
8804 break;
8805
8806 case 7500: hash_type = HASH_TYPE_KRB5PA;
8807 salt_type = SALT_TYPE_EMBEDDED;
8808 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8809 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8810 kern_type = KERN_TYPE_KRB5PA;
8811 dgst_size = DGST_SIZE_4_4;
8812 parse_func = krb5pa_parse_hash;
8813 sort_by_digest = sort_by_digest_4_4;
8814 opti_type = OPTI_TYPE_ZERO_BYTE
8815 | OPTI_TYPE_NOT_ITERATED;
8816 dgst_pos0 = 3;
8817 dgst_pos1 = 7;
8818 dgst_pos2 = 2;
8819 dgst_pos3 = 6;
8820 break;
8821
8822 case 7600: hash_type = HASH_TYPE_SHA1;
8823 salt_type = SALT_TYPE_INTERN;
8824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8825 opts_type = OPTS_TYPE_PT_GENERATE_BE
8826 | OPTS_TYPE_PT_ADD80
8827 | OPTS_TYPE_PT_ADDBITS15;
8828 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8829 dgst_size = DGST_SIZE_4_5;
8830 parse_func = redmine_parse_hash;
8831 sort_by_digest = sort_by_digest_4_5;
8832 opti_type = OPTI_TYPE_ZERO_BYTE
8833 | OPTI_TYPE_PRECOMPUTE_INIT
8834 | OPTI_TYPE_EARLY_SKIP
8835 | OPTI_TYPE_NOT_ITERATED
8836 | OPTI_TYPE_PREPENDED_SALT;
8837 dgst_pos0 = 3;
8838 dgst_pos1 = 4;
8839 dgst_pos2 = 2;
8840 dgst_pos3 = 1;
8841 break;
8842
8843 case 7700: hash_type = HASH_TYPE_SAPB;
8844 salt_type = SALT_TYPE_EMBEDDED;
8845 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8846 opts_type = OPTS_TYPE_PT_GENERATE_LE
8847 | OPTS_TYPE_PT_UPPER
8848 | OPTS_TYPE_ST_UPPER;
8849 kern_type = KERN_TYPE_SAPB;
8850 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8851 parse_func = sapb_parse_hash;
8852 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8853 opti_type = OPTI_TYPE_ZERO_BYTE
8854 | OPTI_TYPE_PRECOMPUTE_INIT
8855 | OPTI_TYPE_NOT_ITERATED;
8856 dgst_pos0 = 0;
8857 dgst_pos1 = 1;
8858 dgst_pos2 = 2;
8859 dgst_pos3 = 3;
8860 break;
8861
8862 case 7800: hash_type = HASH_TYPE_SAPG;
8863 salt_type = SALT_TYPE_EMBEDDED;
8864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8865 opts_type = OPTS_TYPE_PT_GENERATE_BE
8866 | OPTS_TYPE_ST_ADD80
8867 | OPTS_TYPE_ST_UPPER;
8868 kern_type = KERN_TYPE_SAPG;
8869 dgst_size = DGST_SIZE_4_5;
8870 parse_func = sapg_parse_hash;
8871 sort_by_digest = sort_by_digest_4_5;
8872 opti_type = OPTI_TYPE_ZERO_BYTE
8873 | OPTI_TYPE_PRECOMPUTE_INIT
8874 | OPTI_TYPE_NOT_ITERATED;
8875 dgst_pos0 = 3;
8876 dgst_pos1 = 4;
8877 dgst_pos2 = 2;
8878 dgst_pos3 = 1;
8879 break;
8880
8881 case 7900: hash_type = HASH_TYPE_SHA512;
8882 salt_type = SALT_TYPE_EMBEDDED;
8883 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8884 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8885 kern_type = KERN_TYPE_DRUPAL7;
8886 dgst_size = DGST_SIZE_8_8;
8887 parse_func = drupal7_parse_hash;
8888 sort_by_digest = sort_by_digest_8_8;
8889 opti_type = OPTI_TYPE_ZERO_BYTE;
8890 dgst_pos0 = 0;
8891 dgst_pos1 = 1;
8892 dgst_pos2 = 2;
8893 dgst_pos3 = 3;
8894 break;
8895
8896 case 8000: hash_type = HASH_TYPE_SHA256;
8897 salt_type = SALT_TYPE_EMBEDDED;
8898 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8899 opts_type = OPTS_TYPE_PT_GENERATE_BE
8900 | OPTS_TYPE_PT_UNICODE
8901 | OPTS_TYPE_ST_ADD80
8902 | OPTS_TYPE_ST_HEX;
8903 kern_type = KERN_TYPE_SYBASEASE;
8904 dgst_size = DGST_SIZE_4_8;
8905 parse_func = sybasease_parse_hash;
8906 sort_by_digest = sort_by_digest_4_8;
8907 opti_type = OPTI_TYPE_ZERO_BYTE
8908 | OPTI_TYPE_PRECOMPUTE_INIT
8909 | OPTI_TYPE_EARLY_SKIP
8910 | OPTI_TYPE_NOT_ITERATED
8911 | OPTI_TYPE_RAW_HASH;
8912 dgst_pos0 = 3;
8913 dgst_pos1 = 7;
8914 dgst_pos2 = 2;
8915 dgst_pos3 = 6;
8916 break;
8917
8918 case 8100: hash_type = HASH_TYPE_SHA1;
8919 salt_type = SALT_TYPE_EMBEDDED;
8920 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8921 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8922 kern_type = KERN_TYPE_NETSCALER;
8923 dgst_size = DGST_SIZE_4_5;
8924 parse_func = netscaler_parse_hash;
8925 sort_by_digest = sort_by_digest_4_5;
8926 opti_type = OPTI_TYPE_ZERO_BYTE
8927 | OPTI_TYPE_PRECOMPUTE_INIT
8928 | OPTI_TYPE_PRECOMPUTE_MERKLE
8929 | OPTI_TYPE_EARLY_SKIP
8930 | OPTI_TYPE_NOT_ITERATED
8931 | OPTI_TYPE_PREPENDED_SALT
8932 | OPTI_TYPE_RAW_HASH;
8933 dgst_pos0 = 3;
8934 dgst_pos1 = 4;
8935 dgst_pos2 = 2;
8936 dgst_pos3 = 1;
8937 break;
8938
8939 case 8200: hash_type = HASH_TYPE_SHA256;
8940 salt_type = SALT_TYPE_EMBEDDED;
8941 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8942 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8943 kern_type = KERN_TYPE_CLOUDKEY;
8944 dgst_size = DGST_SIZE_4_8;
8945 parse_func = cloudkey_parse_hash;
8946 sort_by_digest = sort_by_digest_4_8;
8947 opti_type = OPTI_TYPE_ZERO_BYTE;
8948 dgst_pos0 = 0;
8949 dgst_pos1 = 1;
8950 dgst_pos2 = 2;
8951 dgst_pos3 = 3;
8952 break;
8953
8954 case 8300: hash_type = HASH_TYPE_SHA1;
8955 salt_type = SALT_TYPE_EMBEDDED;
8956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8957 opts_type = OPTS_TYPE_PT_GENERATE_LE
8958 | OPTS_TYPE_ST_HEX
8959 | OPTS_TYPE_ST_ADD80;
8960 kern_type = KERN_TYPE_NSEC3;
8961 dgst_size = DGST_SIZE_4_5;
8962 parse_func = nsec3_parse_hash;
8963 sort_by_digest = sort_by_digest_4_5;
8964 opti_type = OPTI_TYPE_ZERO_BYTE;
8965 dgst_pos0 = 3;
8966 dgst_pos1 = 4;
8967 dgst_pos2 = 2;
8968 dgst_pos3 = 1;
8969 break;
8970
8971 case 8400: hash_type = HASH_TYPE_SHA1;
8972 salt_type = SALT_TYPE_INTERN;
8973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8974 opts_type = OPTS_TYPE_PT_GENERATE_BE
8975 | OPTS_TYPE_PT_ADD80
8976 | OPTS_TYPE_PT_ADDBITS15;
8977 kern_type = KERN_TYPE_WBB3;
8978 dgst_size = DGST_SIZE_4_5;
8979 parse_func = wbb3_parse_hash;
8980 sort_by_digest = sort_by_digest_4_5;
8981 opti_type = OPTI_TYPE_ZERO_BYTE
8982 | OPTI_TYPE_PRECOMPUTE_INIT
8983 | OPTI_TYPE_NOT_ITERATED;
8984 dgst_pos0 = 3;
8985 dgst_pos1 = 4;
8986 dgst_pos2 = 2;
8987 dgst_pos3 = 1;
8988 break;
8989
8990 case 8500: hash_type = HASH_TYPE_DESRACF;
8991 salt_type = SALT_TYPE_EMBEDDED;
8992 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8993 opts_type = OPTS_TYPE_PT_GENERATE_LE
8994 | OPTS_TYPE_ST_UPPER;
8995 kern_type = KERN_TYPE_RACF;
8996 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8997 parse_func = racf_parse_hash;
8998 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8999 opti_type = OPTI_TYPE_ZERO_BYTE
9000 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9001 dgst_pos0 = 0;
9002 dgst_pos1 = 1;
9003 dgst_pos2 = 2;
9004 dgst_pos3 = 3;
9005 break;
9006
9007 case 8600: hash_type = HASH_TYPE_LOTUS5;
9008 salt_type = SALT_TYPE_NONE;
9009 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9010 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9011 kern_type = KERN_TYPE_LOTUS5;
9012 dgst_size = DGST_SIZE_4_4;
9013 parse_func = lotus5_parse_hash;
9014 sort_by_digest = sort_by_digest_4_4;
9015 opti_type = OPTI_TYPE_EARLY_SKIP
9016 | OPTI_TYPE_NOT_ITERATED
9017 | OPTI_TYPE_NOT_SALTED
9018 | OPTI_TYPE_RAW_HASH;
9019 dgst_pos0 = 0;
9020 dgst_pos1 = 1;
9021 dgst_pos2 = 2;
9022 dgst_pos3 = 3;
9023 break;
9024
9025 case 8700: hash_type = HASH_TYPE_LOTUS6;
9026 salt_type = SALT_TYPE_EMBEDDED;
9027 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9028 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9029 kern_type = KERN_TYPE_LOTUS6;
9030 dgst_size = DGST_SIZE_4_4;
9031 parse_func = lotus6_parse_hash;
9032 sort_by_digest = sort_by_digest_4_4;
9033 opti_type = OPTI_TYPE_EARLY_SKIP
9034 | OPTI_TYPE_NOT_ITERATED
9035 | OPTI_TYPE_RAW_HASH;
9036 dgst_pos0 = 0;
9037 dgst_pos1 = 1;
9038 dgst_pos2 = 2;
9039 dgst_pos3 = 3;
9040 break;
9041
9042 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9043 salt_type = SALT_TYPE_EMBEDDED;
9044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9045 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9046 kern_type = KERN_TYPE_ANDROIDFDE;
9047 dgst_size = DGST_SIZE_4_4;
9048 parse_func = androidfde_parse_hash;
9049 sort_by_digest = sort_by_digest_4_4;
9050 opti_type = OPTI_TYPE_ZERO_BYTE;
9051 dgst_pos0 = 0;
9052 dgst_pos1 = 1;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 3;
9055 break;
9056
9057 case 8900: hash_type = HASH_TYPE_SCRYPT;
9058 salt_type = SALT_TYPE_EMBEDDED;
9059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9060 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9061 kern_type = KERN_TYPE_SCRYPT;
9062 dgst_size = DGST_SIZE_4_8;
9063 parse_func = scrypt_parse_hash;
9064 sort_by_digest = sort_by_digest_4_8;
9065 opti_type = OPTI_TYPE_ZERO_BYTE;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 1;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 3;
9070 break;
9071
9072 case 9000: hash_type = HASH_TYPE_SHA1;
9073 salt_type = SALT_TYPE_EMBEDDED;
9074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9075 opts_type = OPTS_TYPE_PT_GENERATE_LE
9076 | OPTS_TYPE_ST_GENERATE_LE;
9077 kern_type = KERN_TYPE_PSAFE2;
9078 dgst_size = DGST_SIZE_4_5;
9079 parse_func = psafe2_parse_hash;
9080 sort_by_digest = sort_by_digest_4_5;
9081 opti_type = OPTI_TYPE_ZERO_BYTE;
9082 dgst_pos0 = 0;
9083 dgst_pos1 = 1;
9084 dgst_pos2 = 2;
9085 dgst_pos3 = 3;
9086 break;
9087
9088 case 9100: hash_type = HASH_TYPE_LOTUS8;
9089 salt_type = SALT_TYPE_EMBEDDED;
9090 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9091 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9092 kern_type = KERN_TYPE_LOTUS8;
9093 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9094 parse_func = lotus8_parse_hash;
9095 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9096 opti_type = OPTI_TYPE_ZERO_BYTE;
9097 dgst_pos0 = 0;
9098 dgst_pos1 = 1;
9099 dgst_pos2 = 2;
9100 dgst_pos3 = 3;
9101 break;
9102
9103 case 9200: hash_type = HASH_TYPE_SHA256;
9104 salt_type = SALT_TYPE_EMBEDDED;
9105 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9106 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9107 kern_type = KERN_TYPE_PBKDF2_SHA256;
9108 dgst_size = DGST_SIZE_4_32;
9109 parse_func = cisco8_parse_hash;
9110 sort_by_digest = sort_by_digest_4_32;
9111 opti_type = OPTI_TYPE_ZERO_BYTE;
9112 dgst_pos0 = 0;
9113 dgst_pos1 = 1;
9114 dgst_pos2 = 2;
9115 dgst_pos3 = 3;
9116 break;
9117
9118 case 9300: hash_type = HASH_TYPE_SCRYPT;
9119 salt_type = SALT_TYPE_EMBEDDED;
9120 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9121 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9122 kern_type = KERN_TYPE_SCRYPT;
9123 dgst_size = DGST_SIZE_4_8;
9124 parse_func = cisco9_parse_hash;
9125 sort_by_digest = sort_by_digest_4_8;
9126 opti_type = OPTI_TYPE_ZERO_BYTE;
9127 dgst_pos0 = 0;
9128 dgst_pos1 = 1;
9129 dgst_pos2 = 2;
9130 dgst_pos3 = 3;
9131 break;
9132
9133 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9134 salt_type = SALT_TYPE_EMBEDDED;
9135 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9136 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9137 kern_type = KERN_TYPE_OFFICE2007;
9138 dgst_size = DGST_SIZE_4_4;
9139 parse_func = office2007_parse_hash;
9140 sort_by_digest = sort_by_digest_4_4;
9141 opti_type = OPTI_TYPE_ZERO_BYTE;
9142 dgst_pos0 = 0;
9143 dgst_pos1 = 1;
9144 dgst_pos2 = 2;
9145 dgst_pos3 = 3;
9146 break;
9147
9148 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9149 salt_type = SALT_TYPE_EMBEDDED;
9150 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9151 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9152 kern_type = KERN_TYPE_OFFICE2010;
9153 dgst_size = DGST_SIZE_4_4;
9154 parse_func = office2010_parse_hash;
9155 sort_by_digest = sort_by_digest_4_4;
9156 opti_type = OPTI_TYPE_ZERO_BYTE;
9157 dgst_pos0 = 0;
9158 dgst_pos1 = 1;
9159 dgst_pos2 = 2;
9160 dgst_pos3 = 3;
9161 break;
9162
9163 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9164 salt_type = SALT_TYPE_EMBEDDED;
9165 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9166 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9167 kern_type = KERN_TYPE_OFFICE2013;
9168 dgst_size = DGST_SIZE_4_4;
9169 parse_func = office2013_parse_hash;
9170 sort_by_digest = sort_by_digest_4_4;
9171 opti_type = OPTI_TYPE_ZERO_BYTE;
9172 dgst_pos0 = 0;
9173 dgst_pos1 = 1;
9174 dgst_pos2 = 2;
9175 dgst_pos3 = 3;
9176 break;
9177
9178 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9179 salt_type = SALT_TYPE_EMBEDDED;
9180 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9181 opts_type = OPTS_TYPE_PT_GENERATE_LE
9182 | OPTS_TYPE_PT_ADD80
9183 | OPTS_TYPE_PT_UNICODE;
9184 kern_type = KERN_TYPE_OLDOFFICE01;
9185 dgst_size = DGST_SIZE_4_4;
9186 parse_func = oldoffice01_parse_hash;
9187 sort_by_digest = sort_by_digest_4_4;
9188 opti_type = OPTI_TYPE_ZERO_BYTE
9189 | OPTI_TYPE_PRECOMPUTE_INIT
9190 | OPTI_TYPE_NOT_ITERATED;
9191 dgst_pos0 = 0;
9192 dgst_pos1 = 1;
9193 dgst_pos2 = 2;
9194 dgst_pos3 = 3;
9195 break;
9196
9197 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9198 salt_type = SALT_TYPE_EMBEDDED;
9199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9200 opts_type = OPTS_TYPE_PT_GENERATE_LE
9201 | OPTS_TYPE_PT_ADD80;
9202 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9203 dgst_size = DGST_SIZE_4_4;
9204 parse_func = oldoffice01cm1_parse_hash;
9205 sort_by_digest = sort_by_digest_4_4;
9206 opti_type = OPTI_TYPE_ZERO_BYTE
9207 | OPTI_TYPE_PRECOMPUTE_INIT
9208 | OPTI_TYPE_NOT_ITERATED;
9209 dgst_pos0 = 0;
9210 dgst_pos1 = 1;
9211 dgst_pos2 = 2;
9212 dgst_pos3 = 3;
9213 break;
9214
9215 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9216 salt_type = SALT_TYPE_EMBEDDED;
9217 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9218 opts_type = OPTS_TYPE_PT_GENERATE_LE
9219 | OPTS_TYPE_PT_ADD80
9220 | OPTS_TYPE_PT_UNICODE
9221 | OPTS_TYPE_PT_NEVERCRACK;
9222 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9223 dgst_size = DGST_SIZE_4_4;
9224 parse_func = oldoffice01cm2_parse_hash;
9225 sort_by_digest = sort_by_digest_4_4;
9226 opti_type = OPTI_TYPE_ZERO_BYTE
9227 | OPTI_TYPE_PRECOMPUTE_INIT
9228 | OPTI_TYPE_NOT_ITERATED;
9229 dgst_pos0 = 0;
9230 dgst_pos1 = 1;
9231 dgst_pos2 = 2;
9232 dgst_pos3 = 3;
9233 break;
9234
9235 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9236 salt_type = SALT_TYPE_EMBEDDED;
9237 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9238 opts_type = OPTS_TYPE_PT_GENERATE_BE
9239 | OPTS_TYPE_PT_ADD80
9240 | OPTS_TYPE_PT_UNICODE;
9241 kern_type = KERN_TYPE_OLDOFFICE34;
9242 dgst_size = DGST_SIZE_4_4;
9243 parse_func = oldoffice34_parse_hash;
9244 sort_by_digest = sort_by_digest_4_4;
9245 opti_type = OPTI_TYPE_ZERO_BYTE
9246 | OPTI_TYPE_PRECOMPUTE_INIT
9247 | OPTI_TYPE_NOT_ITERATED;
9248 dgst_pos0 = 0;
9249 dgst_pos1 = 1;
9250 dgst_pos2 = 2;
9251 dgst_pos3 = 3;
9252 break;
9253
9254 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9255 salt_type = SALT_TYPE_EMBEDDED;
9256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9257 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9258 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9259 dgst_size = DGST_SIZE_4_4;
9260 parse_func = oldoffice34cm1_parse_hash;
9261 sort_by_digest = sort_by_digest_4_4;
9262 opti_type = OPTI_TYPE_ZERO_BYTE
9263 | OPTI_TYPE_PRECOMPUTE_INIT
9264 | OPTI_TYPE_NOT_ITERATED;
9265 dgst_pos0 = 0;
9266 dgst_pos1 = 1;
9267 dgst_pos2 = 2;
9268 dgst_pos3 = 3;
9269 break;
9270
9271 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9272 salt_type = SALT_TYPE_EMBEDDED;
9273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9274 opts_type = OPTS_TYPE_PT_GENERATE_BE
9275 | OPTS_TYPE_PT_ADD80
9276 | OPTS_TYPE_PT_UNICODE
9277 | OPTS_TYPE_PT_NEVERCRACK;
9278 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9279 dgst_size = DGST_SIZE_4_4;
9280 parse_func = oldoffice34cm2_parse_hash;
9281 sort_by_digest = sort_by_digest_4_4;
9282 opti_type = OPTI_TYPE_ZERO_BYTE
9283 | OPTI_TYPE_PRECOMPUTE_INIT
9284 | OPTI_TYPE_NOT_ITERATED;
9285 dgst_pos0 = 0;
9286 dgst_pos1 = 1;
9287 dgst_pos2 = 2;
9288 dgst_pos3 = 3;
9289 break;
9290
9291 case 9900: hash_type = HASH_TYPE_MD5;
9292 salt_type = SALT_TYPE_NONE;
9293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9294 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9295 kern_type = KERN_TYPE_RADMIN2;
9296 dgst_size = DGST_SIZE_4_4;
9297 parse_func = radmin2_parse_hash;
9298 sort_by_digest = sort_by_digest_4_4;
9299 opti_type = OPTI_TYPE_ZERO_BYTE
9300 | OPTI_TYPE_PRECOMPUTE_INIT
9301 | OPTI_TYPE_EARLY_SKIP
9302 | OPTI_TYPE_NOT_ITERATED
9303 | OPTI_TYPE_NOT_SALTED;
9304 dgst_pos0 = 0;
9305 dgst_pos1 = 3;
9306 dgst_pos2 = 2;
9307 dgst_pos3 = 1;
9308 break;
9309
9310 case 10000: hash_type = HASH_TYPE_SHA256;
9311 salt_type = SALT_TYPE_EMBEDDED;
9312 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9313 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9314 kern_type = KERN_TYPE_PBKDF2_SHA256;
9315 dgst_size = DGST_SIZE_4_32;
9316 parse_func = djangopbkdf2_parse_hash;
9317 sort_by_digest = sort_by_digest_4_32;
9318 opti_type = OPTI_TYPE_ZERO_BYTE;
9319 dgst_pos0 = 0;
9320 dgst_pos1 = 1;
9321 dgst_pos2 = 2;
9322 dgst_pos3 = 3;
9323 break;
9324
9325 case 10100: hash_type = HASH_TYPE_SIPHASH;
9326 salt_type = SALT_TYPE_EMBEDDED;
9327 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9328 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9329 kern_type = KERN_TYPE_SIPHASH;
9330 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9331 parse_func = siphash_parse_hash;
9332 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9333 opti_type = OPTI_TYPE_ZERO_BYTE
9334 | OPTI_TYPE_NOT_ITERATED
9335 | OPTI_TYPE_RAW_HASH;
9336 dgst_pos0 = 0;
9337 dgst_pos1 = 1;
9338 dgst_pos2 = 2;
9339 dgst_pos3 = 3;
9340 break;
9341
9342 case 10200: hash_type = HASH_TYPE_MD5;
9343 salt_type = SALT_TYPE_EMBEDDED;
9344 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9345 opts_type = OPTS_TYPE_PT_GENERATE_LE
9346 | OPTS_TYPE_ST_ADD80
9347 | OPTS_TYPE_ST_ADDBITS14;
9348 kern_type = KERN_TYPE_HMACMD5_PW;
9349 dgst_size = DGST_SIZE_4_4;
9350 parse_func = crammd5_parse_hash;
9351 sort_by_digest = sort_by_digest_4_4;
9352 opti_type = OPTI_TYPE_ZERO_BYTE
9353 | OPTI_TYPE_NOT_ITERATED;
9354 dgst_pos0 = 0;
9355 dgst_pos1 = 3;
9356 dgst_pos2 = 2;
9357 dgst_pos3 = 1;
9358 break;
9359
9360 case 10300: hash_type = HASH_TYPE_SHA1;
9361 salt_type = SALT_TYPE_EMBEDDED;
9362 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9363 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9364 kern_type = KERN_TYPE_SAPH_SHA1;
9365 dgst_size = DGST_SIZE_4_5;
9366 parse_func = saph_sha1_parse_hash;
9367 sort_by_digest = sort_by_digest_4_5;
9368 opti_type = OPTI_TYPE_ZERO_BYTE;
9369 dgst_pos0 = 0;
9370 dgst_pos1 = 1;
9371 dgst_pos2 = 2;
9372 dgst_pos3 = 3;
9373 break;
9374
9375 case 10400: hash_type = HASH_TYPE_PDFU16;
9376 salt_type = SALT_TYPE_EMBEDDED;
9377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9378 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9379 kern_type = KERN_TYPE_PDF11;
9380 dgst_size = DGST_SIZE_4_4;
9381 parse_func = pdf11_parse_hash;
9382 sort_by_digest = sort_by_digest_4_4;
9383 opti_type = OPTI_TYPE_ZERO_BYTE
9384 | OPTI_TYPE_NOT_ITERATED;
9385 dgst_pos0 = 0;
9386 dgst_pos1 = 1;
9387 dgst_pos2 = 2;
9388 dgst_pos3 = 3;
9389 break;
9390
9391 case 10410: hash_type = HASH_TYPE_PDFU16;
9392 salt_type = SALT_TYPE_EMBEDDED;
9393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9394 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9395 kern_type = KERN_TYPE_PDF11CM1;
9396 dgst_size = DGST_SIZE_4_4;
9397 parse_func = pdf11cm1_parse_hash;
9398 sort_by_digest = sort_by_digest_4_4;
9399 opti_type = OPTI_TYPE_ZERO_BYTE
9400 | OPTI_TYPE_NOT_ITERATED;
9401 dgst_pos0 = 0;
9402 dgst_pos1 = 1;
9403 dgst_pos2 = 2;
9404 dgst_pos3 = 3;
9405 break;
9406
9407 case 10420: hash_type = HASH_TYPE_PDFU16;
9408 salt_type = SALT_TYPE_EMBEDDED;
9409 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9410 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9411 kern_type = KERN_TYPE_PDF11CM2;
9412 dgst_size = DGST_SIZE_4_4;
9413 parse_func = pdf11cm2_parse_hash;
9414 sort_by_digest = sort_by_digest_4_4;
9415 opti_type = OPTI_TYPE_ZERO_BYTE
9416 | OPTI_TYPE_NOT_ITERATED;
9417 dgst_pos0 = 0;
9418 dgst_pos1 = 1;
9419 dgst_pos2 = 2;
9420 dgst_pos3 = 3;
9421 break;
9422
9423 case 10500: hash_type = HASH_TYPE_PDFU16;
9424 salt_type = SALT_TYPE_EMBEDDED;
9425 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9426 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9427 kern_type = KERN_TYPE_PDF14;
9428 dgst_size = DGST_SIZE_4_4;
9429 parse_func = pdf14_parse_hash;
9430 sort_by_digest = sort_by_digest_4_4;
9431 opti_type = OPTI_TYPE_ZERO_BYTE
9432 | OPTI_TYPE_NOT_ITERATED;
9433 dgst_pos0 = 0;
9434 dgst_pos1 = 1;
9435 dgst_pos2 = 2;
9436 dgst_pos3 = 3;
9437 break;
9438
9439 case 10600: hash_type = HASH_TYPE_SHA256;
9440 salt_type = SALT_TYPE_EMBEDDED;
9441 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9442 opts_type = OPTS_TYPE_PT_GENERATE_BE
9443 | OPTS_TYPE_ST_ADD80
9444 | OPTS_TYPE_ST_ADDBITS15
9445 | OPTS_TYPE_HASH_COPY;
9446 kern_type = KERN_TYPE_SHA256_PWSLT;
9447 dgst_size = DGST_SIZE_4_8;
9448 parse_func = pdf17l3_parse_hash;
9449 sort_by_digest = sort_by_digest_4_8;
9450 opti_type = OPTI_TYPE_ZERO_BYTE
9451 | OPTI_TYPE_PRECOMPUTE_INIT
9452 | OPTI_TYPE_PRECOMPUTE_MERKLE
9453 | OPTI_TYPE_EARLY_SKIP
9454 | OPTI_TYPE_NOT_ITERATED
9455 | OPTI_TYPE_APPENDED_SALT
9456 | OPTI_TYPE_RAW_HASH;
9457 dgst_pos0 = 3;
9458 dgst_pos1 = 7;
9459 dgst_pos2 = 2;
9460 dgst_pos3 = 6;
9461 break;
9462
9463 case 10700: hash_type = HASH_TYPE_PDFU32;
9464 salt_type = SALT_TYPE_EMBEDDED;
9465 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9466 opts_type = OPTS_TYPE_PT_GENERATE_LE
9467 | OPTS_TYPE_HASH_COPY;
9468 kern_type = KERN_TYPE_PDF17L8;
9469 dgst_size = DGST_SIZE_4_8;
9470 parse_func = pdf17l8_parse_hash;
9471 sort_by_digest = sort_by_digest_4_8;
9472 opti_type = OPTI_TYPE_ZERO_BYTE
9473 | OPTI_TYPE_NOT_ITERATED;
9474 dgst_pos0 = 0;
9475 dgst_pos1 = 1;
9476 dgst_pos2 = 2;
9477 dgst_pos3 = 3;
9478 break;
9479
9480 case 10800: hash_type = HASH_TYPE_SHA384;
9481 salt_type = SALT_TYPE_NONE;
9482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9483 opts_type = OPTS_TYPE_PT_GENERATE_BE
9484 | OPTS_TYPE_PT_ADD80
9485 | OPTS_TYPE_PT_ADDBITS15;
9486 kern_type = KERN_TYPE_SHA384;
9487 dgst_size = DGST_SIZE_8_8;
9488 parse_func = sha384_parse_hash;
9489 sort_by_digest = sort_by_digest_8_8;
9490 opti_type = OPTI_TYPE_ZERO_BYTE
9491 | OPTI_TYPE_PRECOMPUTE_INIT
9492 | OPTI_TYPE_PRECOMPUTE_MERKLE
9493 | OPTI_TYPE_EARLY_SKIP
9494 | OPTI_TYPE_NOT_ITERATED
9495 | OPTI_TYPE_NOT_SALTED
9496 | OPTI_TYPE_RAW_HASH;
9497 dgst_pos0 = 6;
9498 dgst_pos1 = 7;
9499 dgst_pos2 = 4;
9500 dgst_pos3 = 5;
9501 break;
9502
9503 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9504 salt_type = SALT_TYPE_EMBEDDED;
9505 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9506 opts_type = OPTS_TYPE_PT_GENERATE_LE
9507 | OPTS_TYPE_ST_BASE64
9508 | OPTS_TYPE_HASH_COPY;
9509 kern_type = KERN_TYPE_PBKDF2_SHA256;
9510 dgst_size = DGST_SIZE_4_32;
9511 parse_func = pbkdf2_sha256_parse_hash;
9512 sort_by_digest = sort_by_digest_4_32;
9513 opti_type = OPTI_TYPE_ZERO_BYTE;
9514 dgst_pos0 = 0;
9515 dgst_pos1 = 1;
9516 dgst_pos2 = 2;
9517 dgst_pos3 = 3;
9518 break;
9519
9520 case 11000: hash_type = HASH_TYPE_MD5;
9521 salt_type = SALT_TYPE_INTERN;
9522 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9523 opts_type = OPTS_TYPE_PT_GENERATE_LE
9524 | OPTS_TYPE_PT_ADD80;
9525 kern_type = KERN_TYPE_PRESTASHOP;
9526 dgst_size = DGST_SIZE_4_4;
9527 parse_func = prestashop_parse_hash;
9528 sort_by_digest = sort_by_digest_4_4;
9529 opti_type = OPTI_TYPE_ZERO_BYTE
9530 | OPTI_TYPE_PRECOMPUTE_INIT
9531 | OPTI_TYPE_NOT_ITERATED
9532 | OPTI_TYPE_PREPENDED_SALT;
9533 dgst_pos0 = 0;
9534 dgst_pos1 = 3;
9535 dgst_pos2 = 2;
9536 dgst_pos3 = 1;
9537 break;
9538
9539 case 11100: hash_type = HASH_TYPE_MD5;
9540 salt_type = SALT_TYPE_EMBEDDED;
9541 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9542 opts_type = OPTS_TYPE_PT_GENERATE_LE
9543 | OPTS_TYPE_ST_ADD80;
9544 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9545 dgst_size = DGST_SIZE_4_4;
9546 parse_func = postgresql_auth_parse_hash;
9547 sort_by_digest = sort_by_digest_4_4;
9548 opti_type = OPTI_TYPE_ZERO_BYTE
9549 | OPTI_TYPE_PRECOMPUTE_INIT
9550 | OPTI_TYPE_PRECOMPUTE_MERKLE
9551 | OPTI_TYPE_EARLY_SKIP;
9552 dgst_pos0 = 0;
9553 dgst_pos1 = 3;
9554 dgst_pos2 = 2;
9555 dgst_pos3 = 1;
9556 break;
9557
9558 case 11200: hash_type = HASH_TYPE_SHA1;
9559 salt_type = SALT_TYPE_EMBEDDED;
9560 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9561 opts_type = OPTS_TYPE_PT_GENERATE_BE
9562 | OPTS_TYPE_PT_ADD80
9563 | OPTS_TYPE_ST_HEX;
9564 kern_type = KERN_TYPE_MYSQL_AUTH;
9565 dgst_size = DGST_SIZE_4_5;
9566 parse_func = mysql_auth_parse_hash;
9567 sort_by_digest = sort_by_digest_4_5;
9568 opti_type = OPTI_TYPE_ZERO_BYTE
9569 | OPTI_TYPE_EARLY_SKIP;
9570 dgst_pos0 = 3;
9571 dgst_pos1 = 4;
9572 dgst_pos2 = 2;
9573 dgst_pos3 = 1;
9574 break;
9575
9576 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9577 salt_type = SALT_TYPE_EMBEDDED;
9578 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9579 opts_type = OPTS_TYPE_PT_GENERATE_LE
9580 | OPTS_TYPE_ST_HEX
9581 | OPTS_TYPE_ST_ADD80;
9582 kern_type = KERN_TYPE_BITCOIN_WALLET;
9583 dgst_size = DGST_SIZE_4_4;
9584 parse_func = bitcoin_wallet_parse_hash;
9585 sort_by_digest = sort_by_digest_4_4;
9586 opti_type = OPTI_TYPE_ZERO_BYTE;
9587 dgst_pos0 = 0;
9588 dgst_pos1 = 1;
9589 dgst_pos2 = 2;
9590 dgst_pos3 = 3;
9591 break;
9592
9593 case 11400: hash_type = HASH_TYPE_MD5;
9594 salt_type = SALT_TYPE_EMBEDDED;
9595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9596 opts_type = OPTS_TYPE_PT_GENERATE_LE
9597 | OPTS_TYPE_PT_ADD80
9598 | OPTS_TYPE_HASH_COPY;
9599 kern_type = KERN_TYPE_SIP_AUTH;
9600 dgst_size = DGST_SIZE_4_4;
9601 parse_func = sip_auth_parse_hash;
9602 sort_by_digest = sort_by_digest_4_4;
9603 opti_type = OPTI_TYPE_ZERO_BYTE;
9604 dgst_pos0 = 0;
9605 dgst_pos1 = 3;
9606 dgst_pos2 = 2;
9607 dgst_pos3 = 1;
9608 break;
9609
9610 case 11500: hash_type = HASH_TYPE_CRC32;
9611 salt_type = SALT_TYPE_INTERN;
9612 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9613 opts_type = OPTS_TYPE_PT_GENERATE_LE
9614 | OPTS_TYPE_ST_GENERATE_LE
9615 | OPTS_TYPE_ST_HEX;
9616 kern_type = KERN_TYPE_CRC32;
9617 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9618 parse_func = crc32_parse_hash;
9619 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9620 opti_type = OPTI_TYPE_ZERO_BYTE;
9621 dgst_pos0 = 0;
9622 dgst_pos1 = 1;
9623 dgst_pos2 = 2;
9624 dgst_pos3 = 3;
9625 break;
9626
9627 case 11600: hash_type = HASH_TYPE_AES;
9628 salt_type = SALT_TYPE_EMBEDDED;
9629 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9630 opts_type = OPTS_TYPE_PT_GENERATE_LE
9631 | OPTS_TYPE_PT_NEVERCRACK;
9632 kern_type = KERN_TYPE_SEVEN_ZIP;
9633 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9634 parse_func = seven_zip_parse_hash;
9635 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9636 opti_type = OPTI_TYPE_ZERO_BYTE;
9637 dgst_pos0 = 0;
9638 dgst_pos1 = 1;
9639 dgst_pos2 = 2;
9640 dgst_pos3 = 3;
9641 break;
9642
9643 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9644 salt_type = SALT_TYPE_NONE;
9645 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9646 opts_type = OPTS_TYPE_PT_GENERATE_LE
9647 | OPTS_TYPE_PT_ADD01;
9648 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9649 dgst_size = DGST_SIZE_4_8;
9650 parse_func = gost2012sbog_256_parse_hash;
9651 sort_by_digest = sort_by_digest_4_8;
9652 opti_type = OPTI_TYPE_ZERO_BYTE;
9653 dgst_pos0 = 0;
9654 dgst_pos1 = 1;
9655 dgst_pos2 = 2;
9656 dgst_pos3 = 3;
9657 break;
9658
9659 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9660 salt_type = SALT_TYPE_NONE;
9661 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9662 opts_type = OPTS_TYPE_PT_GENERATE_LE
9663 | OPTS_TYPE_PT_ADD01;
9664 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9665 dgst_size = DGST_SIZE_4_16;
9666 parse_func = gost2012sbog_512_parse_hash;
9667 sort_by_digest = sort_by_digest_4_16;
9668 opti_type = OPTI_TYPE_ZERO_BYTE;
9669 dgst_pos0 = 0;
9670 dgst_pos1 = 1;
9671 dgst_pos2 = 2;
9672 dgst_pos3 = 3;
9673 break;
9674
9675 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9676 salt_type = SALT_TYPE_EMBEDDED;
9677 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9678 opts_type = OPTS_TYPE_PT_GENERATE_LE
9679 | OPTS_TYPE_ST_BASE64
9680 | OPTS_TYPE_HASH_COPY;
9681 kern_type = KERN_TYPE_PBKDF2_MD5;
9682 dgst_size = DGST_SIZE_4_32;
9683 parse_func = pbkdf2_md5_parse_hash;
9684 sort_by_digest = sort_by_digest_4_32;
9685 opti_type = OPTI_TYPE_ZERO_BYTE;
9686 dgst_pos0 = 0;
9687 dgst_pos1 = 1;
9688 dgst_pos2 = 2;
9689 dgst_pos3 = 3;
9690 break;
9691
9692 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9693 salt_type = SALT_TYPE_EMBEDDED;
9694 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9695 opts_type = OPTS_TYPE_PT_GENERATE_LE
9696 | OPTS_TYPE_ST_BASE64
9697 | OPTS_TYPE_HASH_COPY;
9698 kern_type = KERN_TYPE_PBKDF2_SHA1;
9699 dgst_size = DGST_SIZE_4_32;
9700 parse_func = pbkdf2_sha1_parse_hash;
9701 sort_by_digest = sort_by_digest_4_32;
9702 opti_type = OPTI_TYPE_ZERO_BYTE;
9703 dgst_pos0 = 0;
9704 dgst_pos1 = 1;
9705 dgst_pos2 = 2;
9706 dgst_pos3 = 3;
9707 break;
9708
9709 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9710 salt_type = SALT_TYPE_EMBEDDED;
9711 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9712 opts_type = OPTS_TYPE_PT_GENERATE_LE
9713 | OPTS_TYPE_ST_BASE64
9714 | OPTS_TYPE_HASH_COPY;
9715 kern_type = KERN_TYPE_PBKDF2_SHA512;
9716 dgst_size = DGST_SIZE_8_16;
9717 parse_func = pbkdf2_sha512_parse_hash;
9718 sort_by_digest = sort_by_digest_8_16;
9719 opti_type = OPTI_TYPE_ZERO_BYTE;
9720 dgst_pos0 = 0;
9721 dgst_pos1 = 1;
9722 dgst_pos2 = 2;
9723 dgst_pos3 = 3;
9724 break;
9725
9726 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9727 salt_type = SALT_TYPE_EMBEDDED;
9728 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9729 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9730 kern_type = KERN_TYPE_ECRYPTFS;
9731 dgst_size = DGST_SIZE_8_8;
9732 parse_func = ecryptfs_parse_hash;
9733 sort_by_digest = sort_by_digest_8_8;
9734 opti_type = OPTI_TYPE_ZERO_BYTE;
9735 dgst_pos0 = 0;
9736 dgst_pos1 = 1;
9737 dgst_pos2 = 2;
9738 dgst_pos3 = 3;
9739 break;
9740
9741 case 12300: hash_type = HASH_TYPE_ORACLET;
9742 salt_type = SALT_TYPE_EMBEDDED;
9743 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9744 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9745 kern_type = KERN_TYPE_ORACLET;
9746 dgst_size = DGST_SIZE_8_16;
9747 parse_func = oraclet_parse_hash;
9748 sort_by_digest = sort_by_digest_8_16;
9749 opti_type = OPTI_TYPE_ZERO_BYTE;
9750 dgst_pos0 = 0;
9751 dgst_pos1 = 1;
9752 dgst_pos2 = 2;
9753 dgst_pos3 = 3;
9754 break;
9755
9756 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9757 salt_type = SALT_TYPE_EMBEDDED;
9758 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9759 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9760 kern_type = KERN_TYPE_BSDICRYPT;
9761 dgst_size = DGST_SIZE_4_4;
9762 parse_func = bsdicrypt_parse_hash;
9763 sort_by_digest = sort_by_digest_4_4;
9764 opti_type = OPTI_TYPE_ZERO_BYTE
9765 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9766 dgst_pos0 = 0;
9767 dgst_pos1 = 1;
9768 dgst_pos2 = 2;
9769 dgst_pos3 = 3;
9770 break;
9771
9772 case 12500: hash_type = HASH_TYPE_RAR3HP;
9773 salt_type = SALT_TYPE_EMBEDDED;
9774 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9775 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9776 kern_type = KERN_TYPE_RAR3;
9777 dgst_size = DGST_SIZE_4_4;
9778 parse_func = rar3hp_parse_hash;
9779 sort_by_digest = sort_by_digest_4_4;
9780 opti_type = OPTI_TYPE_ZERO_BYTE;
9781 dgst_pos0 = 0;
9782 dgst_pos1 = 1;
9783 dgst_pos2 = 2;
9784 dgst_pos3 = 3;
9785 break;
9786
9787 case 12600: hash_type = HASH_TYPE_SHA256;
9788 salt_type = SALT_TYPE_INTERN;
9789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9790 opts_type = OPTS_TYPE_PT_GENERATE_BE
9791 | OPTS_TYPE_PT_ADD80;
9792 kern_type = KERN_TYPE_CF10;
9793 dgst_size = DGST_SIZE_4_8;
9794 parse_func = cf10_parse_hash;
9795 sort_by_digest = sort_by_digest_4_8;
9796 opti_type = OPTI_TYPE_ZERO_BYTE
9797 | OPTI_TYPE_PRECOMPUTE_INIT
9798 | OPTI_TYPE_EARLY_SKIP
9799 | OPTI_TYPE_NOT_ITERATED;
9800 dgst_pos0 = 3;
9801 dgst_pos1 = 7;
9802 dgst_pos2 = 2;
9803 dgst_pos3 = 6;
9804 break;
9805
9806 case 12700: hash_type = HASH_TYPE_AES;
9807 salt_type = SALT_TYPE_EMBEDDED;
9808 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9809 opts_type = OPTS_TYPE_PT_GENERATE_LE
9810 | OPTS_TYPE_HASH_COPY;
9811 kern_type = KERN_TYPE_MYWALLET;
9812 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9813 parse_func = mywallet_parse_hash;
9814 sort_by_digest = sort_by_digest_4_5;
9815 opti_type = OPTI_TYPE_ZERO_BYTE;
9816 dgst_pos0 = 0;
9817 dgst_pos1 = 1;
9818 dgst_pos2 = 2;
9819 dgst_pos3 = 3;
9820 break;
9821
9822 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9823 salt_type = SALT_TYPE_EMBEDDED;
9824 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9825 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9826 kern_type = KERN_TYPE_MS_DRSR;
9827 dgst_size = DGST_SIZE_4_8;
9828 parse_func = ms_drsr_parse_hash;
9829 sort_by_digest = sort_by_digest_4_8;
9830 opti_type = OPTI_TYPE_ZERO_BYTE;
9831 dgst_pos0 = 0;
9832 dgst_pos1 = 1;
9833 dgst_pos2 = 2;
9834 dgst_pos3 = 3;
9835 break;
9836
9837 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9838 salt_type = SALT_TYPE_EMBEDDED;
9839 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9840 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9841 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
9842 dgst_size = DGST_SIZE_4_8;
9843 parse_func = androidfde_samsung_parse_hash;
9844 sort_by_digest = sort_by_digest_4_8;
9845 opti_type = OPTI_TYPE_ZERO_BYTE;
9846 dgst_pos0 = 0;
9847 dgst_pos1 = 1;
9848 dgst_pos2 = 2;
9849 dgst_pos3 = 3;
9850 break;
9851
9852 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
9853 salt_type = SALT_TYPE_EMBEDDED;
9854 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9855 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9856 kern_type = KERN_TYPE_RAR5;
9857 dgst_size = DGST_SIZE_4_4;
9858 parse_func = rar5_parse_hash;
9859 sort_by_digest = sort_by_digest_4_4;
9860 opti_type = OPTI_TYPE_ZERO_BYTE;
9861 dgst_pos0 = 0;
9862 dgst_pos1 = 1;
9863 dgst_pos2 = 2;
9864 dgst_pos3 = 3;
9865 break;
9866
9867 default: usage_mini_print (PROGNAME); return (-1);
9868 }
9869
9870 /**
9871 * transpose
9872 */
9873
9874 data.parse_func = parse_func;
9875
9876 /**
9877 * misc stuff
9878 */
9879
9880 if (hex_salt)
9881 {
9882 if (salt_type == SALT_TYPE_INTERN)
9883 {
9884 opts_type |= OPTS_TYPE_ST_HEX;
9885 }
9886 else
9887 {
9888 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9889
9890 return (-1);
9891 }
9892 }
9893
9894 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9895 | (salt_type == SALT_TYPE_EXTERN)
9896 | (salt_type == SALT_TYPE_EMBEDDED)
9897 | (salt_type == SALT_TYPE_VIRTUAL));
9898
9899 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9900
9901 data.hash_type = hash_type;
9902 data.attack_mode = attack_mode;
9903 data.attack_kern = attack_kern;
9904 data.attack_exec = attack_exec;
9905 data.kern_type = kern_type;
9906 data.opts_type = opts_type;
9907 data.dgst_size = dgst_size;
9908 data.salt_type = salt_type;
9909 data.isSalted = isSalted;
9910 data.sort_by_digest = sort_by_digest;
9911 data.dgst_pos0 = dgst_pos0;
9912 data.dgst_pos1 = dgst_pos1;
9913 data.dgst_pos2 = dgst_pos2;
9914 data.dgst_pos3 = dgst_pos3;
9915
9916 esalt_size = 0;
9917
9918 switch (hash_mode)
9919 {
9920 case 2500: esalt_size = sizeof (wpa_t); break;
9921 case 5300: esalt_size = sizeof (ikepsk_t); break;
9922 case 5400: esalt_size = sizeof (ikepsk_t); break;
9923 case 5500: esalt_size = sizeof (netntlm_t); break;
9924 case 5600: esalt_size = sizeof (netntlm_t); break;
9925 case 6211:
9926 case 6212:
9927 case 6213:
9928 case 6221:
9929 case 6222:
9930 case 6223:
9931 case 6231:
9932 case 6232:
9933 case 6233:
9934 case 6241:
9935 case 6242:
9936 case 6243: esalt_size = sizeof (tc_t); break;
9937 case 6600: esalt_size = sizeof (agilekey_t); break;
9938 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9939 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9940 case 7300: esalt_size = sizeof (rakp_t); break;
9941 case 7500: esalt_size = sizeof (krb5pa_t); break;
9942 case 8200: esalt_size = sizeof (cloudkey_t); break;
9943 case 8800: esalt_size = sizeof (androidfde_t); break;
9944 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9945 case 9400: esalt_size = sizeof (office2007_t); break;
9946 case 9500: esalt_size = sizeof (office2010_t); break;
9947 case 9600: esalt_size = sizeof (office2013_t); break;
9948 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9949 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9950 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9951 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9952 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9953 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9954 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9955 case 10200: esalt_size = sizeof (cram_md5_t); break;
9956 case 10400: esalt_size = sizeof (pdf_t); break;
9957 case 10410: esalt_size = sizeof (pdf_t); break;
9958 case 10420: esalt_size = sizeof (pdf_t); break;
9959 case 10500: esalt_size = sizeof (pdf_t); break;
9960 case 10600: esalt_size = sizeof (pdf_t); break;
9961 case 10700: esalt_size = sizeof (pdf_t); break;
9962 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9963 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9964 case 11400: esalt_size = sizeof (sip_t); break;
9965 case 11600: esalt_size = sizeof (seven_zip_t); break;
9966 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9967 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9968 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9969 case 13000: esalt_size = sizeof (rar5_t); break;
9970 }
9971
9972 data.esalt_size = esalt_size;
9973
9974 /**
9975 * choose dictionary parser
9976 */
9977
9978 if (hash_type == HASH_TYPE_LM)
9979 {
9980 get_next_word_func = get_next_word_lm;
9981 }
9982 else if (opts_type & OPTS_TYPE_PT_UPPER)
9983 {
9984 get_next_word_func = get_next_word_uc;
9985 }
9986 else
9987 {
9988 get_next_word_func = get_next_word_std;
9989 }
9990
9991 /**
9992 * dictstat
9993 */
9994
9995 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
9996
9997 #ifdef _POSIX
9998 size_t dictstat_nmemb = 0;
9999 #endif
10000
10001 #ifdef _WIN
10002 uint dictstat_nmemb = 0;
10003 #endif
10004
10005 char dictstat[256];
10006
10007 FILE *dictstat_fp = NULL;
10008
10009 if (keyspace == 0)
10010 {
10011 memset (dictstat, 0, sizeof (dictstat));
10012
10013 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10014
10015 dictstat_fp = fopen (dictstat, "rb");
10016
10017 if (dictstat_fp)
10018 {
10019 #ifdef _POSIX
10020 struct stat tmpstat;
10021
10022 fstat (fileno (dictstat_fp), &tmpstat);
10023 #endif
10024
10025 #ifdef _WIN
10026 struct stat64 tmpstat;
10027
10028 _fstat64 (fileno (dictstat_fp), &tmpstat);
10029 #endif
10030
10031 if (tmpstat.st_mtime < COMPTIME)
10032 {
10033 /* with v0.15 the format changed so we have to ensure user is using a good version
10034 since there is no version-header in the dictstat file */
10035
10036 fclose (dictstat_fp);
10037
10038 unlink (dictstat);
10039 }
10040 else
10041 {
10042 while (!feof (dictstat_fp))
10043 {
10044 dictstat_t d;
10045
10046 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10047
10048 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10049
10050 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10051 {
10052 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10053
10054 return -1;
10055 }
10056 }
10057
10058 fclose (dictstat_fp);
10059 }
10060 }
10061 }
10062
10063 /**
10064 * potfile
10065 */
10066
10067 char potfile[256];
10068
10069 memset (potfile, 0, sizeof (potfile));
10070
10071 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10072
10073 data.pot_fp = NULL;
10074
10075 FILE *out_fp = NULL;
10076 FILE *pot_fp = NULL;
10077
10078 if (show == 1 || left == 1)
10079 {
10080 pot_fp = fopen (potfile, "rb");
10081
10082 if (pot_fp == NULL)
10083 {
10084 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10085
10086 return (-1);
10087 }
10088
10089 if (outfile != NULL)
10090 {
10091 if ((out_fp = fopen (outfile, "ab")) == NULL)
10092 {
10093 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10094
10095 fclose (pot_fp);
10096
10097 return (-1);
10098 }
10099 }
10100 else
10101 {
10102 out_fp = stdout;
10103 }
10104 }
10105 else
10106 {
10107 if (potfile_disable == 0)
10108 {
10109 pot_fp = fopen (potfile, "ab");
10110
10111 if (pot_fp == NULL)
10112 {
10113 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10114
10115 return (-1);
10116 }
10117
10118 data.pot_fp = pot_fp;
10119 }
10120 }
10121
10122 pot_t *pot = NULL;
10123
10124 uint pot_cnt = 0;
10125 uint pot_avail = 0;
10126
10127 if (show == 1 || left == 1)
10128 {
10129 SUPPRESS_OUTPUT = 1;
10130
10131 pot_avail = count_lines (pot_fp);
10132
10133 rewind (pot_fp);
10134
10135 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10136
10137 uint pot_hashes_avail = 0;
10138
10139 uint line_num = 0;
10140
10141 while (!feof (pot_fp))
10142 {
10143 line_num++;
10144
10145 char line_buf[BUFSIZ];
10146
10147 int line_len = fgetl (pot_fp, line_buf);
10148
10149 if (line_len == 0) continue;
10150
10151 char *plain_buf = line_buf + line_len;
10152
10153 pot_t *pot_ptr = &pot[pot_cnt];
10154
10155 hash_t *hashes_buf = &pot_ptr->hash;
10156
10157 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10158 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10159
10160 if (pot_cnt == pot_hashes_avail)
10161 {
10162 uint pos = 0;
10163
10164 for (pos = 0; pos < INCR_POT; pos++)
10165 {
10166 if ((pot_cnt + pos) >= pot_avail) break;
10167
10168 pot_t *tmp_pot = &pot[pot_cnt + pos];
10169
10170 hash_t *tmp_hash = &tmp_pot->hash;
10171
10172 tmp_hash->digest = mymalloc (dgst_size);
10173
10174 if (isSalted)
10175 {
10176 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10177 }
10178
10179 if (esalt_size)
10180 {
10181 tmp_hash->esalt = mymalloc (esalt_size);
10182 }
10183
10184 pot_hashes_avail++;
10185 }
10186 }
10187
10188 int plain_len = 0;
10189
10190 int parser_status;
10191
10192 int iter = MAX_CUT_TRIES;
10193
10194 do
10195 {
10196 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10197 {
10198 if (line_buf[i] == ':')
10199 {
10200 line_len--;
10201
10202 break;
10203 }
10204 }
10205
10206 if (data.hash_mode != 2500)
10207 {
10208 parser_status = parse_func (line_buf, line_len, hashes_buf);
10209 }
10210 else
10211 {
10212 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10213
10214 if (line_len > max_salt_size)
10215 {
10216 parser_status = PARSER_GLOBAL_LENGTH;
10217 }
10218 else
10219 {
10220 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10221
10222 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10223
10224 hashes_buf->salt->salt_len = line_len;
10225
10226 parser_status = PARSER_OK;
10227 }
10228 }
10229
10230 // if NOT parsed without error, we add the ":" to the plain
10231
10232 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10233 {
10234 plain_len++;
10235 plain_buf--;
10236 }
10237
10238 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10239
10240 if (parser_status < PARSER_GLOBAL_ZERO)
10241 {
10242 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10243
10244 continue;
10245 }
10246
10247 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10248
10249 pot_ptr->plain_len = plain_len;
10250
10251 pot_cnt++;
10252 }
10253
10254 fclose (pot_fp);
10255
10256 SUPPRESS_OUTPUT = 0;
10257
10258 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10259 }
10260
10261 /**
10262 * kernel accel and loops auto adjustment
10263 */
10264
10265 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10266 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10267
10268 if (workload_profile == 1)
10269 {
10270 kernel_loops /= 8;
10271 kernel_accel /= 4;
10272
10273 if (kernel_loops == 0) kernel_loops = 8;
10274 if (kernel_accel == 0) kernel_accel = 2;
10275 }
10276 else if (workload_profile == 3)
10277 {
10278 kernel_loops *= 8;
10279 kernel_accel *= 4;
10280
10281 if (kernel_loops > 1024) kernel_loops = 1024;
10282 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10283 }
10284
10285 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10286
10287 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10288 {
10289 kernel_loops = 1024;
10290 }
10291
10292 if (hash_mode == 12500)
10293 {
10294 kernel_loops = ROUNDS_RAR3 / 16;
10295 }
10296
10297 data.kernel_accel = kernel_accel;
10298 data.kernel_loops = kernel_loops;
10299
10300 /**
10301 * word len
10302 */
10303
10304 uint pw_min = PW_MIN;
10305 uint pw_max = PW_MAX;
10306
10307 switch (hash_mode)
10308 {
10309 case 400: if (pw_max > 40) pw_max = 40;
10310 break;
10311 case 500: if (pw_max > 16) pw_max = 16;
10312 break;
10313 case 1500: if (pw_max > 8) pw_max = 8;
10314 break;
10315 case 1600: if (pw_max > 16) pw_max = 16;
10316 break;
10317 case 1800: if (pw_max > 16) pw_max = 16;
10318 break;
10319 case 2100: if (pw_max > 16) pw_max = 16;
10320 break;
10321 case 2500: if (pw_min < 8) pw_min = 8;
10322 break;
10323 case 3000: if (pw_max > 7) pw_max = 7;
10324 break;
10325 case 5200: if (pw_max > 24) pw_max = 24;
10326 break;
10327 case 5800: if (pw_max > 16) pw_max = 16;
10328 break;
10329 case 6300: if (pw_max > 16) pw_max = 16;
10330 break;
10331 case 7400: if (pw_max > 16) pw_max = 16;
10332 break;
10333 case 7900: if (pw_max > 48) pw_max = 48;
10334 break;
10335 case 8500: if (pw_max > 8) pw_max = 8;
10336 break;
10337 case 8600: if (pw_max > 16) pw_max = 16;
10338 break;
10339 case 9710: pw_min = 5;
10340 pw_max = 5;
10341 break;
10342 case 9810: pw_min = 5;
10343 pw_max = 5;
10344 break;
10345 case 10410: pw_min = 5;
10346 pw_max = 5;
10347 break;
10348 case 10300: if (pw_max < 3) pw_min = 3;
10349 if (pw_max > 40) pw_max = 40;
10350 break;
10351 case 10500: if (pw_max < 3) pw_min = 3;
10352 if (pw_max > 40) pw_max = 40;
10353 break;
10354 case 10700: if (pw_max > 16) pw_max = 16;
10355 break;
10356 case 11300: if (pw_max > 40) pw_max = 40;
10357 break;
10358 case 12500: if (pw_max > 20) pw_max = 20;
10359 break;
10360 case 12800: if (pw_max > 24) pw_max = 24;
10361 break;
10362 }
10363
10364 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10365 {
10366 switch (attack_kern)
10367 {
10368 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10369 break;
10370 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10371 break;
10372 }
10373 }
10374
10375 /**
10376 * charsets : keep them together for more easy maintainnce
10377 */
10378
10379 cs_t mp_sys[6];
10380 cs_t mp_usr[4];
10381
10382 memset (mp_sys, 0, sizeof (mp_sys));
10383 memset (mp_usr, 0, sizeof (mp_usr));
10384
10385 mp_setup_sys (mp_sys);
10386
10387 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10388 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10389 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10390 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10391
10392 /**
10393 * load hashes, part I: find input mode, count hashes
10394 */
10395
10396 uint hashlist_mode = 0;
10397 uint hashlist_format = HLFMT_HASHCAT;
10398
10399 uint hashes_avail = 0;
10400
10401 if (benchmark == 0)
10402 {
10403 struct stat f;
10404
10405 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10406
10407 if ((hash_mode == 2500) ||
10408 (hash_mode == 5200) ||
10409 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10410 (hash_mode == 9000))
10411 {
10412 hashlist_mode = HL_MODE_ARG;
10413
10414 char *hashfile = myargv[optind];
10415
10416 data.hashfile = hashfile;
10417
10418 logfile_top_var_string ("target", hashfile);
10419 }
10420
10421 if (hashlist_mode == HL_MODE_ARG)
10422 {
10423 if (hash_mode == 2500)
10424 {
10425 struct stat st;
10426
10427 if (stat (data.hashfile, &st) == -1)
10428 {
10429 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10430
10431 return (-1);
10432 }
10433
10434 hashes_avail = st.st_size / sizeof (hccap_t);
10435 }
10436 else
10437 {
10438 hashes_avail = 1;
10439 }
10440 }
10441 else if (hashlist_mode == HL_MODE_FILE)
10442 {
10443 char *hashfile = myargv[optind];
10444
10445 data.hashfile = hashfile;
10446
10447 logfile_top_var_string ("target", hashfile);
10448
10449 FILE *fp = NULL;
10450
10451 if ((fp = fopen (hashfile, "rb")) == NULL)
10452 {
10453 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10454
10455 return (-1);
10456 }
10457
10458 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10459
10460 hashes_avail = count_lines (fp);
10461
10462 rewind (fp);
10463
10464 if (hashes_avail == 0)
10465 {
10466 log_error ("ERROR: hashfile is empty or corrupt");
10467
10468 fclose (fp);
10469
10470 return (-1);
10471 }
10472
10473 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10474
10475 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10476 {
10477 log_error ("ERROR: remove not supported in native hashfile-format mode");
10478
10479 fclose (fp);
10480
10481 return (-1);
10482 }
10483
10484 fclose (fp);
10485 }
10486 }
10487 else
10488 {
10489 hashlist_mode = HL_MODE_ARG;
10490
10491 hashes_avail = 1;
10492 }
10493
10494 if (hash_mode == 3000) hashes_avail *= 2;
10495
10496 data.hashlist_mode = hashlist_mode;
10497 data.hashlist_format = hashlist_format;
10498
10499 logfile_top_uint (hashlist_mode);
10500 logfile_top_uint (hashlist_format);
10501
10502 /**
10503 * load hashes, part II: allocate required memory, set pointers
10504 */
10505
10506 hash_t *hashes_buf = NULL;
10507 void *digests_buf = NULL;
10508 salt_t *salts_buf = NULL;
10509 void *esalts_buf = NULL;
10510
10511 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10512
10513 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10514
10515 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10516 {
10517 uint32_t hash_pos;
10518
10519 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10520 {
10521 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10522
10523 hashes_buf[hash_pos].hash_info = hash_info;
10524
10525 if (username && (remove || show || left))
10526 {
10527 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10528 }
10529
10530 if (benchmark)
10531 {
10532 hash_info->orighash = (char *) mymalloc (256);
10533 }
10534 }
10535 }
10536
10537 if (isSalted)
10538 {
10539 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10540
10541 if (esalt_size)
10542 {
10543 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10544 }
10545 }
10546 else
10547 {
10548 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10549 }
10550
10551 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10552 {
10553 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10554
10555 if (isSalted)
10556 {
10557 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10558
10559 if (esalt_size)
10560 {
10561 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10562 }
10563 }
10564 else
10565 {
10566 hashes_buf[hash_pos].salt = &salts_buf[0];
10567 }
10568 }
10569
10570 /**
10571 * load hashes, part III: parse hashes or generate them if benchmark
10572 */
10573
10574 uint hashes_cnt = 0;
10575
10576 if (benchmark == 0)
10577 {
10578 if (keyspace == 1)
10579 {
10580 // useless to read hash file for keyspace, cheat a little bit w/ optind
10581 }
10582 else if (hashes_avail == 0)
10583 {
10584 }
10585 else if (hashlist_mode == HL_MODE_ARG)
10586 {
10587 char *input_buf = myargv[optind];
10588
10589 uint input_len = strlen (input_buf);
10590
10591 logfile_top_var_string ("target", input_buf);
10592
10593 char *hash_buf = NULL;
10594 int hash_len = 0;
10595
10596 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10597
10598 if (hash_len)
10599 {
10600 if (opts_type & OPTS_TYPE_HASH_COPY)
10601 {
10602 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10603
10604 hash_info_tmp->orighash = mystrdup (hash_buf);
10605 }
10606
10607 if (isSalted)
10608 {
10609 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10610 }
10611
10612 int parser_status = PARSER_OK;
10613
10614 if (hash_mode == 2500)
10615 {
10616 if (hash_len == 0)
10617 {
10618 log_error ("ERROR: hccap file not specified");
10619
10620 return (-1);
10621 }
10622
10623 hashlist_mode = HL_MODE_FILE;
10624
10625 data.hashlist_mode = hashlist_mode;
10626
10627 FILE *fp = fopen (hash_buf, "rb");
10628
10629 if (fp == NULL)
10630 {
10631 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10632
10633 return (-1);
10634 }
10635
10636 if (hashes_avail < 1)
10637 {
10638 log_error ("ERROR: hccap file is empty or corrupt");
10639
10640 fclose (fp);
10641
10642 return (-1);
10643 }
10644
10645 uint hccap_size = sizeof (hccap_t);
10646
10647 char in[hccap_size];
10648
10649 while (!feof (fp))
10650 {
10651 int n = fread (&in, hccap_size, 1, fp);
10652
10653 if (n != 1)
10654 {
10655 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10656
10657 break;
10658 }
10659
10660 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10661
10662 if (parser_status != PARSER_OK)
10663 {
10664 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10665
10666 continue;
10667 }
10668
10669 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10670
10671 if ((show == 1) || (left == 1))
10672 {
10673 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10674
10675 char *salt_ptr = (char *) tmp_salt->salt_buf;
10676
10677 int cur_pos = tmp_salt->salt_len;
10678 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10679
10680 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10681
10682 unsigned char *pke_ptr = (unsigned char *) wpa->pke;
10683
10684 // do the appending task
10685
10686 snprintf (salt_ptr + cur_pos,
10687 rem_len,
10688 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10689 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10690 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10691
10692
10693 // memset () the remaining part of the salt
10694
10695 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10696 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10697
10698 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10699
10700 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10701 }
10702
10703 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);
10704 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);
10705
10706 hashes_cnt++;
10707 }
10708
10709 fclose (fp);
10710 }
10711 else if (hash_mode == 3000)
10712 {
10713 if (hash_len == 32)
10714 {
10715 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10716
10717 hash_t *lm_hash_left = NULL;
10718
10719 if (parser_status == PARSER_OK)
10720 {
10721 lm_hash_left = &hashes_buf[hashes_cnt];
10722
10723 hashes_cnt++;
10724 }
10725 else
10726 {
10727 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10728 }
10729
10730
10731 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10732
10733 hash_t *lm_hash_right = NULL;
10734
10735 if (parser_status == PARSER_OK)
10736 {
10737 lm_hash_right = &hashes_buf[hashes_cnt];
10738
10739 hashes_cnt++;
10740 }
10741 else
10742 {
10743 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10744 }
10745
10746 // show / left
10747
10748 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10749 {
10750 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);
10751 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);
10752 }
10753 }
10754 else
10755 {
10756 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10757
10758 if (parser_status == PARSER_OK)
10759 {
10760 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10761 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10762 }
10763
10764 if (parser_status == PARSER_OK)
10765 {
10766 hashes_cnt++;
10767 }
10768 else
10769 {
10770 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10771 }
10772 }
10773 }
10774 else
10775 {
10776 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10777
10778 if (parser_status == PARSER_OK)
10779 {
10780 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10781 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10782 }
10783
10784 if (parser_status == PARSER_OK)
10785 {
10786 hashes_cnt++;
10787 }
10788 else
10789 {
10790 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10791 }
10792 }
10793 }
10794 }
10795 else if (hashlist_mode == HL_MODE_FILE)
10796 {
10797 char *hashfile = data.hashfile;
10798
10799 FILE *fp;
10800
10801 if ((fp = fopen (hashfile, "rb")) == NULL)
10802 {
10803 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10804
10805 return (-1);
10806 }
10807
10808 uint line_num = 0;
10809
10810 while (!feof (fp))
10811 {
10812 line_num++;
10813
10814 char line_buf[BUFSIZ];
10815
10816 int line_len = fgetl (fp, line_buf);
10817
10818 if (line_len == 0) continue;
10819
10820 char *hash_buf = NULL;
10821 int hash_len = 0;
10822
10823 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10824
10825 if (username)
10826 {
10827 char *user_buf = NULL;
10828 int user_len = 0;
10829
10830 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10831
10832 if (remove || show)
10833 {
10834 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10835
10836 *user = (user_t *) malloc (sizeof (user_t));
10837
10838 user_t *user_ptr = *user;
10839
10840 if (user_buf != NULL)
10841 {
10842 user_ptr->user_name = mystrdup (user_buf);
10843 }
10844 else
10845 {
10846 user_ptr->user_name = mystrdup ("");
10847 }
10848
10849 user_ptr->user_len = user_len;
10850 }
10851 }
10852
10853 if (opts_type & OPTS_TYPE_HASH_COPY)
10854 {
10855 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10856
10857 hash_info_tmp->orighash = mystrdup (hash_buf);
10858 }
10859
10860 if (isSalted)
10861 {
10862 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10863 }
10864
10865 if (hash_mode == 3000)
10866 {
10867 if (hash_len == 32)
10868 {
10869 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10870
10871 if (parser_status < PARSER_GLOBAL_ZERO)
10872 {
10873 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10874
10875 continue;
10876 }
10877
10878 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10879
10880 hashes_cnt++;
10881
10882 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10883
10884 if (parser_status < PARSER_GLOBAL_ZERO)
10885 {
10886 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10887
10888 continue;
10889 }
10890
10891 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10892
10893 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);
10894
10895 hashes_cnt++;
10896
10897 // show / left
10898
10899 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);
10900 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);
10901 }
10902 else
10903 {
10904 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10905
10906 if (parser_status < PARSER_GLOBAL_ZERO)
10907 {
10908 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10909
10910 continue;
10911 }
10912
10913 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);
10914
10915 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10916 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10917
10918 hashes_cnt++;
10919 }
10920 }
10921 else
10922 {
10923 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10924
10925 if (parser_status < PARSER_GLOBAL_ZERO)
10926 {
10927 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10928
10929 continue;
10930 }
10931
10932 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);
10933
10934 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10935 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10936
10937 hashes_cnt++;
10938 }
10939 }
10940
10941 fclose (fp);
10942
10943 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10944
10945 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10946 }
10947 }
10948 else
10949 {
10950 if (isSalted)
10951 {
10952 hashes_buf[0].salt->salt_len = 8;
10953
10954 // special salt handling
10955
10956 switch (hash_mode)
10957 {
10958 case 1500: hashes_buf[0].salt->salt_len = 2;
10959 break;
10960 case 1731: hashes_buf[0].salt->salt_len = 4;
10961 break;
10962 case 2410: hashes_buf[0].salt->salt_len = 4;
10963 break;
10964 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10965 break;
10966 case 3100: hashes_buf[0].salt->salt_len = 1;
10967 break;
10968 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10969 break;
10970 case 5800: hashes_buf[0].salt->salt_len = 16;
10971 break;
10972 case 6800: hashes_buf[0].salt->salt_len = 32;
10973 break;
10974 case 8400: hashes_buf[0].salt->salt_len = 40;
10975 break;
10976 case 8800: hashes_buf[0].salt->salt_len = 16;
10977 break;
10978 case 8900: hashes_buf[0].salt->salt_len = 16;
10979 hashes_buf[0].salt->scrypt_N = 1024;
10980 hashes_buf[0].salt->scrypt_r = 1;
10981 hashes_buf[0].salt->scrypt_p = 1;
10982 break;
10983 case 9100: hashes_buf[0].salt->salt_len = 16;
10984 break;
10985 case 9300: hashes_buf[0].salt->salt_len = 14;
10986 hashes_buf[0].salt->scrypt_N = 16384;
10987 hashes_buf[0].salt->scrypt_r = 1;
10988 hashes_buf[0].salt->scrypt_p = 1;
10989 break;
10990 case 9400: hashes_buf[0].salt->salt_len = 16;
10991 break;
10992 case 9500: hashes_buf[0].salt->salt_len = 16;
10993 break;
10994 case 9600: hashes_buf[0].salt->salt_len = 16;
10995 break;
10996 case 9700: hashes_buf[0].salt->salt_len = 16;
10997 break;
10998 case 9710: hashes_buf[0].salt->salt_len = 16;
10999 break;
11000 case 9720: hashes_buf[0].salt->salt_len = 16;
11001 break;
11002 case 9800: hashes_buf[0].salt->salt_len = 16;
11003 break;
11004 case 9810: hashes_buf[0].salt->salt_len = 16;
11005 break;
11006 case 9820: hashes_buf[0].salt->salt_len = 16;
11007 break;
11008 case 10300: hashes_buf[0].salt->salt_len = 12;
11009 break;
11010 case 11500: hashes_buf[0].salt->salt_len = 4;
11011 break;
11012 case 11600: hashes_buf[0].salt->salt_len = 4;
11013 break;
11014 case 12400: hashes_buf[0].salt->salt_len = 4;
11015 break;
11016 case 12500: hashes_buf[0].salt->salt_len = 8;
11017 break;
11018 case 12600: hashes_buf[0].salt->salt_len = 64;
11019 break;
11020 }
11021
11022 // special esalt handling
11023
11024 switch (hash_mode)
11025 {
11026 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11027 break;
11028 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11029 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11030 break;
11031 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11032 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11033 break;
11034 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11035 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11036 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11037 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11038 break;
11039 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11040 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11041 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11042 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11043 break;
11044 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11045 break;
11046 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11047 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11048 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11049 break;
11050 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11051 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11052 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11053 break;
11054 case 10420: ((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 10500: ((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 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11063 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11064 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11065 break;
11066 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11067 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11068 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11069 break;
11070 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11071 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11072 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11073 break;
11074 }
11075 }
11076
11077 // set hashfile
11078
11079 switch (hash_mode)
11080 {
11081 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11082 break;
11083 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11084 break;
11085 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11086 break;
11087 case 6211:
11088 case 6212:
11089 case 6213:
11090 case 6221:
11091 case 6222:
11092 case 6223:
11093 case 6231:
11094 case 6232:
11095 case 6233:
11096 case 6241:
11097 case 6242:
11098 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11099 break;
11100 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11101 break;
11102 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11103 break;
11104 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11105 break;
11106 }
11107
11108 // set default iterations
11109
11110 switch (hash_mode)
11111 {
11112 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11113 break;
11114 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11115 break;
11116 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11117 break;
11118 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11119 break;
11120 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11121 break;
11122 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11123 break;
11124 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11125 break;
11126 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11127 break;
11128 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11129 break;
11130 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11131 break;
11132 case 6211:
11133 case 6212:
11134 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11135 break;
11136 case 6221:
11137 case 6222:
11138 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11139 break;
11140 case 6231:
11141 case 6232:
11142 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11143 break;
11144 case 6241:
11145 case 6242:
11146 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11147 break;
11148 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11149 break;
11150 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11151 break;
11152 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11153 break;
11154 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11155 break;
11156 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11157 break;
11158 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11159 break;
11160 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11161 break;
11162 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11163 break;
11164 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11165 break;
11166 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11167 break;
11168 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11169 break;
11170 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11171 break;
11172 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11173 break;
11174 case 8900: hashes_buf[0].salt->salt_iter = 1;
11175 break;
11176 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11177 break;
11178 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11179 break;
11180 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11181 break;
11182 case 9300: hashes_buf[0].salt->salt_iter = 1;
11183 break;
11184 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11185 break;
11186 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11187 break;
11188 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11189 break;
11190 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11191 break;
11192 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11193 break;
11194 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11195 break;
11196 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11197 break;
11198 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11199 break;
11200 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11201 break;
11202 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11203 break;
11204 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11205 break;
11206 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11207 break;
11208 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11209 break;
11210 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11211 break;
11212 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11213 break;
11214 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11215 break;
11216 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11217 break;
11218 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11219 break;
11220 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11221 break;
11222 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11223 break;
11224 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11225 break;
11226 }
11227
11228 // set special tuning for benchmark-mode 1
11229
11230 if (benchmark_mode == 1)
11231 {
11232 kernel_loops *= 8;
11233 kernel_accel *= 4;
11234
11235 switch (hash_mode)
11236 {
11237 case 400: kernel_loops = ROUNDS_PHPASS;
11238 kernel_accel = 32;
11239 break;
11240 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11241 kernel_accel = 32;
11242 break;
11243 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11244 kernel_accel = 32;
11245 break;
11246 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11247 kernel_accel = 32;
11248 break;
11249 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11250 kernel_accel = 16;
11251 break;
11252 case 2100: kernel_loops = ROUNDS_DCC2;
11253 kernel_accel = 16;
11254 break;
11255 case 2500: kernel_loops = ROUNDS_WPA2;
11256 kernel_accel = 32;
11257 break;
11258 case 3200: kernel_loops = ROUNDS_BCRYPT;
11259 kernel_accel = 8;
11260 break;
11261 case 5200: kernel_loops = ROUNDS_PSAFE3;
11262 kernel_accel = 16;
11263 break;
11264 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11265 kernel_accel = 16;
11266 break;
11267 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11268 kernel_accel = 64;
11269 break;
11270 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11271 kernel_accel = 32;
11272 break;
11273 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11274 kernel_accel = 32;
11275 break;
11276 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11277 kernel_accel = 8;
11278 break;
11279 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11280 kernel_accel = 8;
11281 break;
11282 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11283 kernel_accel = 8;
11284 break;
11285 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11286 kernel_accel = 8;
11287 break;
11288 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11289 kernel_accel = 8;
11290 break;
11291 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11292 kernel_accel = 8;
11293 break;
11294 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11295 kernel_accel = 128;
11296 break;
11297 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11298 kernel_accel = 64;
11299 break;
11300 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11301 kernel_accel = 64;
11302 break;
11303 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11304 kernel_accel = 32;
11305 break;
11306 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11307 kernel_accel = 128;
11308 break;
11309 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11310 kernel_accel = 128;
11311 break;
11312 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11313 kernel_accel = 32;
11314 break;
11315 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11316 kernel_accel = 64;
11317 break;
11318 case 6800: kernel_loops = ROUNDS_LASTPASS;
11319 kernel_accel = 64;
11320 break;
11321 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11322 kernel_accel = 8;
11323 break;
11324 case 7200: kernel_loops = ROUNDS_GRUB;
11325 kernel_accel = 16;
11326 break;
11327 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11328 kernel_accel = 8;
11329 break;
11330 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11331 kernel_accel = 8;
11332 break;
11333 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11334 kernel_accel = 8;
11335 break;
11336 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11337 kernel_accel = 32;
11338 break;
11339 case 8900: kernel_loops = 1;
11340 kernel_accel = 64;
11341 break;
11342 case 9000: kernel_loops = ROUNDS_PSAFE2;
11343 kernel_accel = 16;
11344 break;
11345 case 9100: kernel_loops = ROUNDS_LOTUS8;
11346 kernel_accel = 64;
11347 break;
11348 case 9200: kernel_loops = ROUNDS_CISCO8;
11349 kernel_accel = 8;
11350 break;
11351 case 9300: kernel_loops = 1;
11352 kernel_accel = 4;
11353 break;
11354 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11355 kernel_accel = 32;
11356 break;
11357 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11358 kernel_accel = 32;
11359 break;
11360 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11361 kernel_accel = 8;
11362 break;
11363 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11364 kernel_accel = 8;
11365 break;
11366 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11367 kernel_accel = 16;
11368 break;
11369 case 10500: kernel_loops = ROUNDS_PDF14;
11370 kernel_accel = 256;
11371 break;
11372 case 10700: kernel_loops = ROUNDS_PDF17L8;
11373 kernel_accel = 8;
11374 break;
11375 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11376 kernel_accel = 8;
11377 break;
11378 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11379 kernel_accel = 8;
11380 break;
11381 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11382 kernel_accel = 8;
11383 break;
11384 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11385 kernel_accel = 8;
11386 break;
11387 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11388 kernel_accel = 8;
11389 break;
11390 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11391 kernel_accel = 8;
11392 break;
11393 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11394 kernel_accel = 8;
11395 break;
11396 case 12300: kernel_loops = ROUNDS_ORACLET;
11397 kernel_accel = 8;
11398 break;
11399 case 12500: kernel_loops = ROUNDS_RAR3;
11400 kernel_accel = 32;
11401 break;
11402 case 12700: kernel_loops = ROUNDS_MYWALLET;
11403 kernel_accel = 512;
11404 break;
11405 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11406 kernel_accel = 512;
11407 break;
11408 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11409 kernel_accel = 8;
11410 break;
11411 case 13000: kernel_loops = ROUNDS_RAR5;
11412 kernel_accel = 8;
11413 break;
11414 }
11415
11416 // some algorithm collide too fast, make that impossible
11417
11418 switch (hash_mode)
11419 {
11420 case 11500: ((uint *) digests_buf)[1] = 1;
11421 break;
11422 }
11423
11424 if (kernel_loops > 1024) kernel_loops = 1024;
11425 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11426 }
11427
11428 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11429 {
11430 kernel_loops = 1024;
11431 }
11432
11433 if (hash_mode == 12500)
11434 {
11435 kernel_loops = ROUNDS_RAR3 / 16;
11436 }
11437
11438 data.kernel_accel = kernel_accel;
11439 data.kernel_loops = kernel_loops;
11440
11441 hashes_cnt = 1;
11442 }
11443
11444 if (show == 1 || left == 1)
11445 {
11446 for (uint i = 0; i < pot_cnt; i++)
11447 {
11448 pot_t *pot_ptr = &pot[i];
11449
11450 hash_t *hashes_buf = &pot_ptr->hash;
11451
11452 local_free (hashes_buf->digest);
11453
11454 if (isSalted)
11455 {
11456 local_free (hashes_buf->salt);
11457 }
11458 }
11459
11460 local_free (pot);
11461
11462 if (data.quiet == 0) log_info_nn ("");
11463
11464 return (0);
11465 }
11466
11467 if (keyspace == 0)
11468 {
11469 if (hashes_cnt == 0)
11470 {
11471 log_error ("ERROR: No hashes loaded");
11472
11473 return (-1);
11474 }
11475 }
11476
11477 /**
11478 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11479 */
11480
11481 if (data.outfile != NULL)
11482 {
11483 if (data.hashfile != NULL)
11484 {
11485 #ifdef _POSIX
11486 struct stat tmpstat_outfile;
11487 struct stat tmpstat_hashfile;
11488 #endif
11489
11490 #ifdef _WIN
11491 struct stat64 tmpstat_outfile;
11492 struct stat64 tmpstat_hashfile;
11493 #endif
11494
11495 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11496
11497 if (tmp_outfile_fp)
11498 {
11499 #ifdef _POSIX
11500 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11501 #endif
11502
11503 #ifdef _WIN
11504 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11505 #endif
11506
11507 fclose (tmp_outfile_fp);
11508 }
11509
11510 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11511
11512 if (tmp_hashfile_fp)
11513 {
11514 #ifdef _POSIX
11515 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11516 #endif
11517
11518 #ifdef _WIN
11519 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11520 #endif
11521
11522 fclose (tmp_hashfile_fp);
11523 }
11524
11525 if (tmp_outfile_fp && tmp_outfile_fp)
11526 {
11527 tmpstat_outfile.st_mode = 0;
11528 tmpstat_outfile.st_nlink = 0;
11529 tmpstat_outfile.st_uid = 0;
11530 tmpstat_outfile.st_gid = 0;
11531 tmpstat_outfile.st_rdev = 0;
11532 tmpstat_outfile.st_atime = 0;
11533
11534 tmpstat_hashfile.st_mode = 0;
11535 tmpstat_hashfile.st_nlink = 0;
11536 tmpstat_hashfile.st_uid = 0;
11537 tmpstat_hashfile.st_gid = 0;
11538 tmpstat_hashfile.st_rdev = 0;
11539 tmpstat_hashfile.st_atime = 0;
11540
11541 #ifdef _POSIX
11542 tmpstat_outfile.st_blksize = 0;
11543 tmpstat_outfile.st_blocks = 0;
11544
11545 tmpstat_hashfile.st_blksize = 0;
11546 tmpstat_hashfile.st_blocks = 0;
11547 #endif
11548
11549 #ifdef _POSIX
11550 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11551 {
11552 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11553
11554 return (-1);
11555 }
11556 #endif
11557
11558 #ifdef _WIN
11559 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11560 {
11561 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11562
11563 return (-1);
11564 }
11565 #endif
11566 }
11567 }
11568 }
11569
11570 /**
11571 * Remove duplicates
11572 */
11573
11574 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11575
11576 if (isSalted)
11577 {
11578 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11579 }
11580 else
11581 {
11582 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11583 }
11584
11585 uint hashes_cnt_orig = hashes_cnt;
11586
11587 hashes_cnt = 1;
11588
11589 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11590 {
11591 if (isSalted)
11592 {
11593 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11594 {
11595 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11596 }
11597 }
11598 else
11599 {
11600 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11601 }
11602
11603 if (hashes_pos > hashes_cnt)
11604 {
11605 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11606 }
11607
11608 hashes_cnt++;
11609 }
11610
11611 /**
11612 * Potfile removes
11613 */
11614
11615 uint potfile_remove_cracks = 0;
11616
11617 if (potfile_disable == 0)
11618 {
11619 hash_t hash_buf;
11620
11621 hash_buf.digest = mymalloc (dgst_size);
11622 hash_buf.salt = NULL;
11623 hash_buf.esalt = NULL;
11624 hash_buf.hash_info = NULL;
11625 hash_buf.cracked = 0;
11626
11627 if (isSalted)
11628 {
11629 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11630 }
11631
11632 if (esalt_size)
11633 {
11634 hash_buf.esalt = mymalloc (esalt_size);
11635 }
11636
11637 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11638
11639 // no solution for these special hash types (for instane because they use hashfile in output etc)
11640 if ((hash_mode != 5200) &&
11641 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11642 (hash_mode != 9000))
11643 {
11644 FILE *fp = fopen (potfile, "rb");
11645
11646 if (fp != NULL)
11647 {
11648 while (!feof (fp))
11649 {
11650 char line_buf[BUFSIZ];
11651
11652 memset (line_buf, 0, BUFSIZ);
11653
11654 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11655
11656 if (ptr == NULL) break;
11657
11658 int line_len = strlen (line_buf);
11659
11660 if (line_len == 0) continue;
11661
11662 int iter = MAX_CUT_TRIES;
11663
11664 for (int i = line_len - 1; i && iter; i--, line_len--)
11665 {
11666 if (line_buf[i] != ':') continue;
11667
11668 if (isSalted)
11669 {
11670 memset (hash_buf.salt, 0, sizeof (salt_t));
11671 }
11672
11673 hash_t *found = NULL;
11674
11675 if (hash_mode == 6800)
11676 {
11677 if (i < 48) // 48 = 12 * uint in salt_buf[]
11678 {
11679 // manipulate salt_buf
11680 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11681
11682 hash_buf.salt->salt_len = i;
11683
11684 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11685 }
11686 }
11687 else if (hash_mode == 2500)
11688 {
11689 if (i < 48) // 48 = 12 * uint in salt_buf[]
11690 {
11691 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11692 // manipulate salt_buf
11693
11694 // to be safe work with a copy (because of line_len loop, i etc)
11695
11696 char line_buf_cpy[BUFSIZ];
11697 memset (line_buf_cpy, 0, BUFSIZ);
11698
11699 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11700
11701 memcpy (line_buf_cpy, line_buf, i);
11702
11703 char *mac2_pos = strrchr (line_buf_cpy, ':');
11704
11705 if (mac2_pos == NULL) continue;
11706
11707 mac2_pos[0] = 0;
11708 mac2_pos++;
11709
11710 if (strlen (mac2_pos) != 12) continue;
11711
11712 char *mac1_pos = strrchr (line_buf_cpy, ':');
11713
11714 if (mac1_pos == NULL) continue;
11715
11716 mac1_pos[0] = 0;
11717 mac1_pos++;
11718
11719 if (strlen (mac1_pos) != 12) continue;
11720
11721 uint essid_length = mac1_pos - line_buf_cpy - 1;
11722
11723 // here we need the ESSID
11724 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11725
11726 hash_buf.salt->salt_len = essid_length;
11727
11728 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11729
11730 if (found)
11731 {
11732 wpa_t *wpa = (wpa_t *) found->esalt;
11733
11734 uint pke[25];
11735
11736 char *pke_ptr = (char *) pke;
11737
11738 for (uint i = 0; i < 25; i++)
11739 {
11740 pke[i] = byte_swap_32 (wpa->pke[i]);
11741 }
11742
11743 unsigned char mac1[6];
11744 unsigned char mac2[6];
11745
11746 memcpy (mac1, pke_ptr + 23, 6);
11747 memcpy (mac2, pke_ptr + 29, 6);
11748
11749 // compare hex string(s) vs binary MAC address(es)
11750
11751 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11752 {
11753 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
11754 {
11755 found = NULL;
11756 break;
11757 }
11758 }
11759
11760 // early skip ;)
11761 if (!found) continue;
11762
11763 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11764 {
11765 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
11766 {
11767 found = NULL;
11768 break;
11769 }
11770 }
11771 }
11772 }
11773 }
11774 else
11775 {
11776 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11777
11778 if (parser_status == PARSER_OK)
11779 {
11780 if (isSalted)
11781 {
11782 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11783 }
11784 else
11785 {
11786 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11787 }
11788 }
11789 }
11790
11791 if (found == NULL) continue;
11792
11793 if (!found->cracked) potfile_remove_cracks++;
11794
11795 found->cracked = 1;
11796
11797 if (found) break;
11798
11799 iter--;
11800 }
11801 }
11802
11803 fclose (fp);
11804 }
11805 }
11806
11807 if (esalt_size)
11808 {
11809 local_free (hash_buf.esalt);
11810 }
11811
11812 if (isSalted)
11813 {
11814 local_free (hash_buf.salt);
11815 }
11816
11817 local_free (hash_buf.digest);
11818 }
11819
11820 /**
11821 * Now generate all the buffers required for later
11822 */
11823
11824 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11825
11826 salt_t *salts_buf_new = NULL;
11827 void *esalts_buf_new = NULL;
11828
11829 if (isSalted)
11830 {
11831 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11832
11833 if (esalt_size)
11834 {
11835 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11836 }
11837 }
11838 else
11839 {
11840 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11841 }
11842
11843 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11844
11845 uint digests_cnt = hashes_cnt;
11846 uint digests_done = 0;
11847
11848 uint size_digests = digests_cnt * dgst_size;
11849 uint size_shown = digests_cnt * sizeof (uint);
11850
11851 uint *digests_shown = (uint *) mymalloc (size_shown);
11852 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11853
11854 uint salts_cnt = 0;
11855 uint salts_done = 0;
11856
11857 hashinfo_t **hash_info = NULL;
11858
11859 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11860 {
11861 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11862
11863 if (username && (remove || show))
11864 {
11865 uint user_pos;
11866
11867 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11868 {
11869 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11870
11871 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11872 }
11873 }
11874 }
11875
11876 uint *salts_shown = (uint *) mymalloc (size_shown);
11877
11878 salt_t *salt_buf;
11879
11880 {
11881 // copied from inner loop
11882
11883 salt_buf = &salts_buf_new[salts_cnt];
11884
11885 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11886
11887 if (esalt_size)
11888 {
11889 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11890 }
11891
11892 salt_buf->digests_cnt = 0;
11893 salt_buf->digests_done = 0;
11894 salt_buf->digests_offset = 0;
11895
11896 salts_cnt++;
11897 }
11898
11899 if (hashes_buf[0].cracked == 1)
11900 {
11901 digests_shown[0] = 1;
11902
11903 digests_done++;
11904
11905 salt_buf->digests_done++;
11906 }
11907
11908 salt_buf->digests_cnt++;
11909
11910 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11911
11912 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11913 {
11914 hash_info[0] = hashes_buf[0].hash_info;
11915 }
11916
11917 // copy from inner loop
11918
11919 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11920 {
11921 if (isSalted)
11922 {
11923 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11924 {
11925 salt_buf = &salts_buf_new[salts_cnt];
11926
11927 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11928
11929 if (esalt_size)
11930 {
11931 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11932 }
11933
11934 salt_buf->digests_cnt = 0;
11935 salt_buf->digests_done = 0;
11936 salt_buf->digests_offset = hashes_pos;
11937
11938 salts_cnt++;
11939 }
11940 }
11941
11942 if (hashes_buf[hashes_pos].cracked == 1)
11943 {
11944 digests_shown[hashes_pos] = 1;
11945
11946 digests_done++;
11947
11948 salt_buf->digests_done++;
11949 }
11950
11951 salt_buf->digests_cnt++;
11952
11953 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11954
11955 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11956 {
11957 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11958 }
11959 }
11960
11961 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11962 {
11963 salt_t *salt_buf = &salts_buf_new[salt_pos];
11964
11965 if (salt_buf->digests_done == salt_buf->digests_cnt)
11966 {
11967 salts_shown[salt_pos] = 1;
11968
11969 salts_done++;
11970 }
11971
11972 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11973 }
11974
11975 local_free (digests_buf);
11976 local_free (salts_buf);
11977 local_free (esalts_buf);
11978
11979 digests_buf = digests_buf_new;
11980 salts_buf = salts_buf_new;
11981 esalts_buf = esalts_buf_new;
11982
11983 local_free (hashes_buf);
11984
11985 /**
11986 * special modification not set from parser
11987 */
11988
11989 switch (hash_mode)
11990 {
11991 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11992 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11993 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11994 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11995 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11996 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11997 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11998 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11999 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12000 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12001 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12002 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12003 }
12004
12005 if (truecrypt_keyfiles)
12006 {
12007 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12008
12009 char *keyfiles = strdup (truecrypt_keyfiles);
12010
12011 char *keyfile = strtok (keyfiles, ",");
12012
12013 do
12014 {
12015 truecrypt_crc32 (keyfile, (unsigned char *) keyfile_buf);
12016
12017 } while ((keyfile = strtok (NULL, ",")) != NULL);
12018
12019 free (keyfiles);
12020 }
12021
12022 data.digests_cnt = digests_cnt;
12023 data.digests_done = digests_done;
12024 data.digests_buf = digests_buf;
12025 data.digests_shown = digests_shown;
12026 data.digests_shown_tmp = digests_shown_tmp;
12027
12028 data.salts_cnt = salts_cnt;
12029 data.salts_done = salts_done;
12030 data.salts_buf = salts_buf;
12031 data.salts_shown = salts_shown;
12032
12033 data.esalts_buf = esalts_buf;
12034 data.hash_info = hash_info;
12035
12036 /**
12037 * Automatic Optimizers
12038 */
12039
12040 if (salts_cnt == 1)
12041 opti_type |= OPTI_TYPE_SINGLE_SALT;
12042
12043 if (digests_cnt == 1)
12044 opti_type |= OPTI_TYPE_SINGLE_HASH;
12045
12046 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12047 opti_type |= OPTI_TYPE_NOT_ITERATED;
12048
12049 if (attack_mode == ATTACK_MODE_BF)
12050 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12051
12052 data.opti_type = opti_type;
12053
12054 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12055 {
12056 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12057 {
12058 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12059 {
12060 if (opts_type & OPTS_TYPE_ST_ADD80)
12061 {
12062 opts_type &= ~OPTS_TYPE_ST_ADD80;
12063 opts_type |= OPTS_TYPE_PT_ADD80;
12064 }
12065
12066 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12067 {
12068 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12069 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12070 }
12071
12072 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12073 {
12074 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12075 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12076 }
12077 }
12078 }
12079 }
12080
12081 /**
12082 * Some algorithm, like descrypt, can benefit from JIT compilation
12083 */
12084
12085 uint force_jit_compilation = 0;
12086
12087 if (hash_mode == 8900)
12088 {
12089 force_jit_compilation = 8900;
12090 }
12091 else if (hash_mode == 9300)
12092 {
12093 force_jit_compilation = 8900;
12094 }
12095 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12096 {
12097 force_jit_compilation = 1500;
12098 }
12099
12100 /**
12101 * generate bitmap tables
12102 */
12103
12104 const uint bitmap_shift1 = 5;
12105 const uint bitmap_shift2 = 13;
12106
12107 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12108
12109 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12110 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12111 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12112 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12113 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12114 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12115 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12116 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12117
12118 uint bitmap_bits;
12119 uint bitmap_nums;
12120 uint bitmap_mask;
12121 uint bitmap_size;
12122
12123 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12124 {
12125 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12126
12127 bitmap_nums = 1 << bitmap_bits;
12128
12129 bitmap_mask = bitmap_nums - 1;
12130
12131 bitmap_size = bitmap_nums * sizeof (uint);
12132
12133 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12134
12135 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;
12136 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;
12137
12138 break;
12139 }
12140
12141 bitmap_nums = 1 << bitmap_bits;
12142
12143 bitmap_mask = bitmap_nums - 1;
12144
12145 bitmap_size = bitmap_nums * sizeof (uint);
12146
12147 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);
12148 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);
12149
12150 /**
12151 * prepare quick rule
12152 */
12153
12154 data.rule_buf_l = rule_buf_l;
12155 data.rule_buf_r = rule_buf_r;
12156
12157 int rule_len_l = (int) strlen (rule_buf_l);
12158 int rule_len_r = (int) strlen (rule_buf_r);
12159
12160 data.rule_len_l = rule_len_l;
12161 data.rule_len_r = rule_len_r;
12162
12163 /**
12164 * load rules
12165 */
12166
12167 uint *all_kernel_rules_cnt = NULL;
12168
12169 kernel_rule_t **all_kernel_rules_buf = NULL;
12170
12171 if (rp_files_cnt)
12172 {
12173 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12174
12175 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12176 }
12177
12178 char rule_buf[BUFSIZ];
12179
12180 int rule_len = 0;
12181
12182 for (uint i = 0; i < rp_files_cnt; i++)
12183 {
12184 uint kernel_rules_avail = 0;
12185
12186 uint kernel_rules_cnt = 0;
12187
12188 kernel_rule_t *kernel_rules_buf = NULL;
12189
12190 char *rp_file = rp_files[i];
12191
12192 char in[BLOCK_SIZE];
12193 char out[BLOCK_SIZE];
12194
12195 FILE *fp = NULL;
12196
12197 uint rule_line = 0;
12198
12199 if ((fp = fopen (rp_file, "rb")) == NULL)
12200 {
12201 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12202
12203 return (-1);
12204 }
12205
12206 while (!feof (fp))
12207 {
12208 memset (rule_buf, 0, BUFSIZ);
12209
12210 rule_len = fgetl (fp, rule_buf);
12211
12212 rule_line++;
12213
12214 if (rule_len == 0) continue;
12215
12216 if (rule_buf[0] == '#') continue;
12217
12218 if (kernel_rules_avail == kernel_rules_cnt)
12219 {
12220 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12221
12222 kernel_rules_avail += INCR_RULES;
12223 }
12224
12225 memset (in, 0, BLOCK_SIZE);
12226 memset (out, 0, BLOCK_SIZE);
12227
12228 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12229
12230 if (result == -1)
12231 {
12232 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12233
12234 continue;
12235 }
12236
12237 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12238 {
12239 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12240
12241 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12242
12243 continue;
12244 }
12245
12246 /* its so slow
12247 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12248 {
12249 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12250
12251 continue;
12252 }
12253 */
12254
12255 kernel_rules_cnt++;
12256 }
12257
12258 fclose (fp);
12259
12260 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12261
12262 all_kernel_rules_buf[i] = kernel_rules_buf;
12263 }
12264
12265 /**
12266 * merge rules or automatic rule generator
12267 */
12268
12269 uint kernel_rules_cnt = 0;
12270
12271 kernel_rule_t *kernel_rules_buf = NULL;
12272
12273 if (attack_mode == ATTACK_MODE_STRAIGHT)
12274 {
12275 if (rp_files_cnt)
12276 {
12277 kernel_rules_cnt = 1;
12278
12279 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12280
12281 repeats[0] = kernel_rules_cnt;
12282
12283 for (uint i = 0; i < rp_files_cnt; i++)
12284 {
12285 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12286
12287 repeats[i + 1] = kernel_rules_cnt;
12288 }
12289
12290 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12291
12292 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12293
12294 for (uint i = 0; i < kernel_rules_cnt; i++)
12295 {
12296 uint out_pos = 0;
12297
12298 kernel_rule_t *out = &kernel_rules_buf[i];
12299
12300 for (uint j = 0; j < rp_files_cnt; j++)
12301 {
12302 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12303 uint in_pos;
12304
12305 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12306
12307 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12308 {
12309 if (out_pos == RULES_MAX - 1)
12310 {
12311 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12312
12313 break;
12314 }
12315
12316 out->cmds[out_pos] = in->cmds[in_pos];
12317 }
12318 }
12319 }
12320
12321 local_free (repeats);
12322 }
12323 else if (rp_gen)
12324 {
12325 uint kernel_rules_avail = 0;
12326
12327 while (kernel_rules_cnt < rp_gen)
12328 {
12329 if (kernel_rules_avail == kernel_rules_cnt)
12330 {
12331 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12332
12333 kernel_rules_avail += INCR_RULES;
12334 }
12335
12336 memset (rule_buf, 0, BLOCK_SIZE);
12337
12338 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12339
12340 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12341
12342 kernel_rules_cnt++;
12343 }
12344 }
12345 }
12346
12347 /**
12348 * generate NOP rules
12349 */
12350
12351 if (kernel_rules_cnt == 0)
12352 {
12353 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12354
12355 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12356
12357 kernel_rules_cnt++;
12358 }
12359
12360 data.kernel_rules_cnt = kernel_rules_cnt;
12361 data.kernel_rules_buf = kernel_rules_buf;
12362
12363 /**
12364 * OpenCL platforms: detect
12365 */
12366
12367 cl_platform_id CL_platforms[CL_PLATFORMS_MAX];
12368
12369 uint CL_platforms_cnt = 0;
12370
12371 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, CL_platforms, &CL_platforms_cnt);
12372
12373 if (CL_platforms_cnt == 0)
12374 {
12375 log_error ("ERROR: No OpenCL compatible platform found");
12376
12377 return (-1);
12378 }
12379
12380 /**
12381 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12382 */
12383
12384 for (uint i = 0; i < CL_platforms_cnt; i++)
12385 {
12386 cl_platform_id CL_platform = CL_platforms[i];
12387
12388 char CL_platform_vendor[INFOSZ];
12389
12390 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12391
12392 hc_clGetPlatformInfo (CL_platform, CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12393
12394 if (strcmp (CL_platform_vendor, CL_VENDOR_NV) == 0)
12395 {
12396 // make sure that we do not directly control the fan for NVidia
12397
12398 gpu_temp_retain = 0;
12399
12400 data.gpu_temp_retain = gpu_temp_retain;
12401 }
12402 }
12403
12404 /**
12405 * OpenCL devices: push all devices from all platforms into the same device array
12406 */
12407
12408 uint devices_plf[DEVICES_MAX]; // device number on platform, required for hardware-management mapping
12409
12410 cl_device_id devices_all[DEVICES_MAX];
12411 cl_device_id devices[DEVICES_MAX];
12412
12413 uint devices_all_cnt = 0;
12414 uint devices_cnt = 0;
12415
12416 for (uint i = 0; i < CL_platforms_cnt; i++)
12417 {
12418 if ((opencl_platforms_filter & (1 << i)) == 0) continue;
12419
12420 cl_platform_id CL_platform = CL_platforms[i];
12421
12422 cl_device_id devices_platform[DEVICES_MAX];
12423
12424 cl_uint devices_platform_cnt = 0;
12425
12426 hc_clGetDeviceIDs (CL_platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, devices_platform, &devices_platform_cnt);
12427
12428 for (uint j = 0; j < devices_platform_cnt; j++)
12429 {
12430 devices_all[devices_all_cnt] = devices_platform[j];
12431 devices_plf[devices_all_cnt] = j;
12432
12433 devices_all_cnt++;
12434 }
12435 }
12436
12437 /**
12438 * enable custom signal handler(s)
12439 */
12440
12441 if (benchmark == 0)
12442 {
12443 hc_signal (sigHandler_default);
12444 }
12445 else
12446 {
12447 hc_signal (sigHandler_benchmark);
12448 }
12449
12450 /**
12451 * devices mask and properties
12452 */
12453
12454 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
12455 {
12456 // skip the device, if the user did specify a list of GPUs to skip
12457
12458 if (opencl_devicemask)
12459 {
12460 uint device_all_id_mask = 1 << device_all_id;
12461
12462 if ((device_all_id_mask & opencl_devicemask) != device_all_id_mask)
12463 {
12464 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped", device_all_id + 1);
12465
12466 continue;
12467 }
12468 }
12469
12470 const uint device_id = devices_cnt;
12471
12472 devices[device_id] = devices_all[device_all_id];
12473
12474 devices_plf[device_id] = devices_plf[device_all_id];
12475
12476 cl_device_type device_type = 0;
12477
12478 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12479
12480 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12481
12482 if ((device_type & device_types_filter) == 0)
12483 {
12484 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped", device_all_id + 1);
12485
12486 continue;
12487 }
12488
12489 char device_name[INFOSZ];
12490 char device_version[INFOSZ];
12491
12492 memset (device_name, 0, sizeof (device_name));
12493 memset (device_version, 0, sizeof (device_version));
12494
12495 cl_ulong global_mem_size;
12496 cl_ulong max_mem_alloc_size;
12497 cl_uint max_clock_frequency;
12498 cl_uint max_compute_units;
12499
12500 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
12501 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
12502 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12503 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
12504 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12505 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_VERSION, sizeof (device_version), &device_version, NULL);
12506
12507 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12508 {
12509 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12510 device_all_id + 1,
12511 device_name,
12512 (unsigned int) (max_mem_alloc_size / 1024 / 1024),
12513 (unsigned int) (global_mem_size / 1024 / 1024),
12514 (unsigned int) (max_clock_frequency),
12515 (unsigned int) max_compute_units);
12516 }
12517
12518 if (strstr (device_version, "pocl"))
12519 {
12520 if (force == 0)
12521 {
12522 log_info ("");
12523 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12524 log_info ("You are STRONGLY encouraged not to use it");
12525 log_info ("You can use --force to override this but do not post error reports if you do so");
12526 log_info ("");
12527
12528 return (-1);
12529 }
12530 }
12531
12532 devices_cnt++;
12533 }
12534
12535 if (devices_cnt == 0)
12536 {
12537 log_error ("ERROR: No devices left that matches your specification.");
12538
12539 return (-1);
12540 }
12541
12542 data.devices_cnt = devices_cnt;
12543
12544 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12545 {
12546 log_info ("");
12547 }
12548
12549 /**
12550 * User-defined GPU temp handling
12551 */
12552
12553 if (gpu_temp_disable == 1)
12554 {
12555 gpu_temp_abort = 0;
12556 gpu_temp_retain = 0;
12557 }
12558
12559 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12560 {
12561 if (gpu_temp_abort < gpu_temp_retain)
12562 {
12563 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12564
12565 return (-1);
12566 }
12567 }
12568
12569 data.gpu_temp_disable = gpu_temp_disable;
12570 data.gpu_temp_abort = gpu_temp_abort;
12571 data.gpu_temp_retain = gpu_temp_retain;
12572
12573 /**
12574 * inform the user
12575 */
12576
12577 if (data.quiet == 0)
12578 {
12579 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12580
12581 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);
12582
12583 if (attack_mode == ATTACK_MODE_STRAIGHT)
12584 {
12585 log_info ("Rules: %u", kernel_rules_cnt);
12586 }
12587
12588 if (opti_type)
12589 {
12590 log_info ("Applicable Optimizers:");
12591
12592 for (uint i = 0; i < 32; i++)
12593 {
12594 const uint opti_bit = 1 << i;
12595
12596 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12597 }
12598 }
12599
12600 /**
12601 * Watchdog and Temperature balance
12602 */
12603
12604 if (gpu_temp_abort == 0)
12605 {
12606 log_info ("Watchdog: Temperature abort trigger disabled");
12607 }
12608 else
12609 {
12610 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12611 }
12612
12613 if (gpu_temp_retain == 0)
12614 {
12615 log_info ("Watchdog: Temperature retain trigger disabled");
12616 }
12617 else
12618 {
12619 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12620 }
12621 }
12622
12623 if (data.quiet == 0) log_info ("");
12624
12625 /**
12626 * devices init
12627 */
12628
12629 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12630
12631 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12632
12633 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12634
12635 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
12636
12637 data.devices_param = devices_param;
12638
12639 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12640 {
12641 hc_device_param_t *device_param = &data.devices_param[device_id];
12642
12643 cl_device_id device = devices[device_id];
12644
12645 device_param->device = device;
12646
12647 cl_device_type device_type = 0;
12648
12649 hc_clGetDeviceInfo (device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12650
12651 device_param->device_type = device_type;
12652
12653 cl_uint max_compute_units = 0;
12654
12655 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12656
12657 device_param->device_processors = max_compute_units;
12658
12659 cl_ulong max_mem_alloc_size = 0;
12660
12661 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12662
12663 device_param->device_maxmem_alloc = max_mem_alloc_size;
12664
12665 cl_uint vendor_id = 0;
12666
12667 hc_clGetDeviceInfo (device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12668
12669 device_param->vendor_id = vendor_id;
12670
12671 char tmp[INFOSZ], t1[64];
12672
12673 memset (tmp, 0, sizeof (tmp));
12674
12675 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
12676
12677 device_param->device_name = mystrdup (tmp);
12678
12679 memset (tmp, 0, sizeof (tmp));
12680
12681 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
12682
12683 if (strstr (tmp, "pocl"))
12684 {
12685 // pocl returns the real AMD vendor_id id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12686 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12687
12688 cl_uint vendor_id = 0xffff;
12689
12690 device_param->vendor_id = vendor_id;
12691 }
12692
12693 memset (t1, 0, sizeof (t1));
12694
12695 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
12696
12697 device_param->device_version = mystrdup (t1);
12698
12699 memset (tmp, 0, sizeof (tmp));
12700
12701 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
12702
12703 device_param->driver_version = mystrdup (tmp);
12704
12705 // create some filename that is easier to read on cached folder
12706
12707 snprintf (tmp, sizeof (tmp) - 1, "%u-%s-%s-%s-%d", device_param->vendor_id, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12708
12709 uint device_name_digest[4];
12710
12711 device_name_digest[0] = 0;
12712 device_name_digest[1] = 0;
12713 device_name_digest[2] = 0;
12714 device_name_digest[3] = 0;
12715
12716 md5_64 ((uint *) tmp, device_name_digest);
12717
12718 sprintf (tmp, "%08x", device_name_digest[0]);
12719
12720 device_param->device_name_chksum = mystrdup (tmp);
12721
12722 if (device_type & CL_DEVICE_TYPE_CPU)
12723 {
12724 cl_uint device_processor_cores = 1;
12725
12726 device_param->device_processor_cores = device_processor_cores;
12727 }
12728
12729 if (device_type & CL_DEVICE_TYPE_GPU)
12730 {
12731 if (vendor_id == VENDOR_ID_AMD)
12732 {
12733 cl_uint device_processor_cores = 0;
12734
12735 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12736
12737 hc_clGetDeviceInfo (device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12738
12739 device_param->device_processor_cores = device_processor_cores;
12740 }
12741 else if (vendor_id == VENDOR_ID_NV)
12742 {
12743 cl_uint kernel_exec_timeout = 0;
12744
12745 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12746
12747 hc_clGetDeviceInfo (device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12748
12749 device_param->kernel_exec_timeout = kernel_exec_timeout;
12750
12751 cl_uint device_processor_cores = 0;
12752
12753 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12754
12755 hc_clGetDeviceInfo (device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12756
12757 device_param->device_processor_cores = device_processor_cores;
12758
12759 cl_uint sm_minor = 0;
12760 cl_uint sm_major = 0;
12761
12762 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12763 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12764
12765 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12766 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12767
12768 device_param->sm_minor = sm_minor;
12769 device_param->sm_major = sm_major;
12770 }
12771 else
12772 {
12773 cl_uint device_processor_cores = 1;
12774
12775 device_param->device_processor_cores = device_processor_cores;
12776 }
12777 }
12778
12779 /**
12780 * common driver check
12781 */
12782
12783 if (device_type & CL_DEVICE_TYPE_GPU)
12784 {
12785 if (vendor_id == VENDOR_ID_NV)
12786 {
12787 if (device_param->kernel_exec_timeout != 0)
12788 {
12789 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);
12790 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12791 }
12792 }
12793 else if (vendor_id == VENDOR_ID_AMD)
12794 {
12795 int catalyst_check = (force == 1) ? 0 : 1;
12796
12797 int catalyst_warn = 0;
12798
12799 int catalyst_broken = 0;
12800
12801 if (catalyst_check == 1)
12802 {
12803 catalyst_warn = 1;
12804
12805 // v14.9 and higher
12806 if ((atoi (device_param->device_version) >= 1573)
12807 && (atoi (device_param->driver_version) >= 1573))
12808 {
12809 catalyst_warn = 0;
12810 }
12811
12812 catalyst_check = 0;
12813 }
12814
12815 if (catalyst_broken == 1)
12816 {
12817 log_error ("");
12818 log_error ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12819 log_error ("It will pass over cracked hashes and does not report them as cracked");
12820 log_error ("You are STRONGLY encouraged not to use it");
12821 log_error ("You can use --force to override this but do not post error reports if you do so");
12822
12823 return (-1);
12824 }
12825
12826 if (catalyst_warn == 1)
12827 {
12828 log_error ("");
12829 log_error ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12830 log_error ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12831 log_error ("See oclHashcat's homepage for official supported catalyst drivers");
12832 #ifdef _WIN
12833 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12834 #endif
12835 log_error ("You can use --force to override this but do not post error reports if you do so");
12836
12837 return (-1);
12838 }
12839 }
12840 }
12841 }
12842
12843 /**
12844 * HM devices: init
12845 */
12846
12847 hm_attrs_t hm_adapters_nv[DEVICES_MAX];
12848 hm_attrs_t hm_adapters_amd[DEVICES_MAX];
12849
12850 memset (hm_adapters_nv, 0, sizeof (hm_adapters_nv));
12851 memset (hm_adapters_amd, 0, sizeof (hm_adapters_amd));
12852
12853 if (gpu_temp_disable == 0)
12854 {
12855 #ifdef WIN
12856 if (NvAPI_Initialize () == NVAPI_OK)
12857 {
12858 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12859
12860 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12861
12862 int tmp_out = 0;
12863
12864 for (int i = 0; i < tmp_in; i++)
12865 {
12866 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12867 }
12868
12869 for (int i = 0; i < tmp_out; i++)
12870 {
12871 NvU32 speed;
12872
12873 if (NvAPI_GPU_GetTachReading (hm_adapters_nv[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
12874 }
12875 }
12876 #endif
12877
12878 #ifdef LINUX
12879 HM_LIB hm_dll_nv = hm_init (VENDOR_ID_NV);
12880
12881 data.hm_dll_nv = hm_dll_nv;
12882
12883 if (hm_dll_nv)
12884 {
12885 if (hc_NVML_nvmlInit (hm_dll_nv) == NVML_SUCCESS)
12886 {
12887 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12888
12889 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12890
12891 int tmp_out = 0;
12892
12893 for (int i = 0; i < tmp_in; i++)
12894 {
12895 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12896 }
12897
12898 for (int i = 0; i < tmp_out; i++)
12899 {
12900 unsigned int speed;
12901
12902 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;
12903 }
12904 }
12905 }
12906 #endif
12907
12908 HM_LIB hm_dll_amd = hm_init (VENDOR_ID_AMD);
12909
12910 data.hm_dll_amd = hm_dll_amd;
12911
12912 if (hm_dll_amd)
12913 {
12914 if (hc_ADL_Main_Control_Create (hm_dll_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12915 {
12916 // total number of adapters
12917
12918 int hm_adapters_num;
12919
12920 if (get_adapters_num_amd (hm_dll_amd, &hm_adapters_num) != 0) return (-1);
12921
12922 // adapter info
12923
12924 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll_amd, hm_adapters_num);
12925
12926 if (lpAdapterInfo == NULL) return (-1);
12927
12928 // get a list (of ids of) valid/usable adapters
12929
12930 int num_adl_adapters = 0;
12931
12932 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12933
12934 if (num_adl_adapters > 0)
12935 {
12936 hc_thread_mutex_lock (mux_adl);
12937
12938 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
12939
12940 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12941
12942 hm_get_overdrive_version (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12943 hm_check_fanspeed_control (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12944
12945 hc_thread_mutex_unlock (mux_adl);
12946 }
12947
12948 myfree (valid_adl_device_list);
12949 myfree (lpAdapterInfo);
12950 }
12951 }
12952 }
12953
12954 /**
12955 * HM devices: copy
12956 */
12957
12958 if (gpu_temp_disable == 0)
12959 {
12960 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12961 {
12962 hc_device_param_t *device_param = &data.devices_param[device_id];
12963
12964 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
12965
12966 cl_uint device_id_on_platform = devices_plf[device_id];
12967
12968 if (device_param->vendor_id == VENDOR_ID_NV)
12969 {
12970 memcpy (&data.hm_device[device_id], &hm_adapters_nv[device_id_on_platform], sizeof (hm_attrs_t));
12971 }
12972
12973 if (device_param->vendor_id == VENDOR_ID_AMD)
12974 {
12975 memcpy (&data.hm_device[device_id], &hm_adapters_amd[device_id_on_platform], sizeof (hm_attrs_t));
12976 }
12977 }
12978 }
12979
12980 /*
12981 * Temporary fix:
12982 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12983 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
12984 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
12985 * Driver / ADL bug?
12986 */
12987
12988 if (powertune_enable == 1)
12989 {
12990 hc_thread_mutex_lock (mux_adl);
12991
12992 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12993 {
12994 if (data.hm_device[device_id].od_version == 6)
12995 {
12996 // set powertune value only
12997
12998 int powertune_supported = 0;
12999
13000 int ADL_rc = 0;
13001
13002 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13003 {
13004 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13005
13006 return (-1);
13007 }
13008
13009 if (powertune_supported != 0)
13010 {
13011 // powertune set
13012 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13013
13014 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13015 {
13016 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13017
13018 return (-1);
13019 }
13020
13021 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13022 {
13023 log_error ("ERROR: Failed to set new ADL PowerControl values");
13024
13025 return (-1);
13026 }
13027 }
13028 }
13029 }
13030
13031 hc_thread_mutex_unlock (mux_adl);
13032 }
13033
13034 uint kernel_blocks_all = 0;
13035
13036 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13037 {
13038 /**
13039 * host buffer
13040 */
13041
13042 hc_device_param_t *device_param = &data.devices_param[device_id];
13043
13044 /**
13045 * device properties
13046 */
13047
13048 char *device_name_chksum = device_param->device_name_chksum;
13049
13050 uint device_processors = device_param->device_processors;
13051
13052 uint device_processor_cores = device_param->device_processor_cores;
13053
13054 cl_device_type device_type = device_param->device_type;
13055
13056 /**
13057 * create context for each device
13058 */
13059
13060 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13061
13062 /**
13063 * create command-queue
13064 */
13065
13066 // not support with NV
13067 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13068
13069 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13070
13071 /**
13072 * create input buffers on device
13073 */
13074
13075 uint kernel_threads = KERNEL_THREADS;
13076
13077 // bcrypt
13078 if (hash_mode == 3200) kernel_threads = 8;
13079 if (hash_mode == 9000) kernel_threads = 8;
13080
13081 if (device_type & CL_DEVICE_TYPE_CPU)
13082 {
13083 // CPU still need lots of workitems, don't know why...
13084 // for testing phase, lets start with this
13085
13086 kernel_accel = 1;
13087 }
13088
13089 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13090 uint kernel_blocks = kernel_power;
13091
13092 device_param->kernel_threads = kernel_threads;
13093 device_param->kernel_power_user = kernel_power;
13094 device_param->kernel_blocks_user = kernel_blocks;
13095
13096 kernel_blocks_all += kernel_blocks;
13097
13098 uint size_pws = kernel_power * sizeof (pw_t);
13099
13100 uint size_tmps = 4;
13101
13102 switch (hash_mode)
13103 {
13104 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13105 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13106 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13107 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13108 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13109 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13110 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13111 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13112 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13113 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13114 case 6211:
13115 case 6212:
13116 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13117 case 6221:
13118 case 6222:
13119 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13120 case 6231:
13121 case 6232:
13122 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13123 case 6241:
13124 case 6242:
13125 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13126 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13127 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13128 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13129 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13130 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13131 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13132 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13133 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13134 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13135 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13136 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13137 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13138 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13139 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13140 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13141 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13142 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13143 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13144 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13145 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13146 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13147 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13148 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13149 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13150 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13151 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13152 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13153 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13154 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13155 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13156 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13157 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13158 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13159 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13160 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13161 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13162 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13163 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13164 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13165 };
13166
13167 uint size_hooks = 4;
13168
13169 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13170 {
13171 // insert correct hook size
13172 }
13173
13174 // we can optimize some stuff here...
13175
13176 device_param->size_pws = size_pws;
13177 device_param->size_tmps = size_tmps;
13178 device_param->size_hooks = size_hooks;
13179
13180 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13181 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13182
13183 device_param->size_root_css = size_root_css;
13184 device_param->size_markov_css = size_markov_css;
13185
13186 uint size_results = KERNEL_THREADS * sizeof (uint);
13187
13188 device_param->size_results = size_results;
13189
13190 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13191 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13192
13193 uint size_plains = digests_cnt * sizeof (plain_t);
13194 uint size_salts = salts_cnt * sizeof (salt_t);
13195 uint size_esalts = salts_cnt * esalt_size;
13196
13197 device_param->size_plains = size_plains;
13198 device_param->size_digests = size_digests;
13199 device_param->size_shown = size_shown;
13200 device_param->size_salts = size_salts;
13201
13202 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13203 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13204 uint size_tm = 32 * sizeof (bs_word_t);
13205
13206 uint64_t size_scryptV = 1;
13207
13208 if ((hash_mode == 8900) || (hash_mode == 9300))
13209 {
13210 uint tmto_start = 0;
13211 uint tmto_stop = 10;
13212
13213 if (scrypt_tmto)
13214 {
13215 tmto_start = scrypt_tmto;
13216 }
13217 else
13218 {
13219 // in case the user did not specify the tmto manually
13220 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13221 // but set the lower end only in case the user has a device with too less memory
13222
13223 if (hash_mode == 8900)
13224 {
13225 if (device_param->vendor_id == VENDOR_ID_AMD)
13226 {
13227 tmto_start = 1;
13228 }
13229 else if (device_param->vendor_id == VENDOR_ID_NV)
13230 {
13231 tmto_start = 3;
13232 }
13233 }
13234 else if (hash_mode == 9300)
13235 {
13236 if (device_param->vendor_id == VENDOR_ID_AMD)
13237 {
13238 tmto_start = 3;
13239 }
13240 else if (device_param->vendor_id == VENDOR_ID_NV)
13241 {
13242 tmto_start = 5;
13243 }
13244 }
13245 }
13246
13247 if (quiet == 0) log_info ("");
13248
13249 uint shader_per_mp = 1;
13250
13251 if (device_param->vendor_id == VENDOR_ID_AMD)
13252 {
13253 shader_per_mp = 8;
13254 }
13255 else if (device_param->vendor_id == VENDOR_ID_NV)
13256 {
13257 shader_per_mp = 32;
13258 }
13259
13260 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13261 {
13262 // TODO: in theory the following calculation needs to be done per salt, not global
13263 // we assume all hashes have the same scrypt settings
13264
13265 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13266
13267 size_scryptV /= 1 << tmto;
13268
13269 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13270
13271 if (size_scryptV > device_param->device_maxmem_alloc)
13272 {
13273 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13274
13275 continue;
13276 }
13277
13278 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13279 {
13280 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13281 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13282 }
13283
13284 break;
13285 }
13286
13287 if (data.salts_buf[0].scrypt_phy == 0)
13288 {
13289 log_error ("ERROR: can't allocate enough device memory");
13290
13291 return -1;
13292 }
13293
13294 if (quiet == 0) log_info ("");
13295 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13296 }
13297
13298 /**
13299 * default building options
13300 */
13301
13302 char build_opts[1024];
13303
13304 // we don't have sm_* on vendors not NV but it doesn't matter
13305
13306 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);
13307
13308 /**
13309 * main kernel
13310 */
13311
13312 {
13313 /**
13314 * kernel source filename
13315 */
13316
13317 char source_file[256];
13318
13319 memset (source_file, 0, sizeof (source_file));
13320
13321 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13322
13323 struct stat sst;
13324
13325 if (stat (source_file, &sst) == -1)
13326 {
13327 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13328
13329 return -1;
13330 }
13331
13332 /**
13333 * kernel cached filename
13334 */
13335
13336 char cached_file[256];
13337
13338 memset (cached_file, 0, sizeof (cached_file));
13339
13340 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13341
13342 int cached = 1;
13343
13344 struct stat cst;
13345
13346 if (stat (cached_file, &cst) == -1)
13347 {
13348 cached = 0;
13349 }
13350
13351 /**
13352 * kernel compile or load
13353 */
13354
13355 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13356
13357 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13358
13359 if (force_jit_compilation == 0)
13360 {
13361 if (cached == 0)
13362 {
13363 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13364
13365 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13366
13367 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13368
13369 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13370
13371 size_t binary_size;
13372
13373 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13374
13375 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13376
13377 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13378
13379 writeProgramBin (cached_file, binary, binary_size);
13380
13381 local_free (binary);
13382 }
13383 else
13384 {
13385 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13386
13387 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13388
13389 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13390
13391 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13392 }
13393 }
13394 else
13395 {
13396 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13397
13398 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13399
13400 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13401
13402 if (force_jit_compilation == 1500)
13403 {
13404 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13405 }
13406 else if (force_jit_compilation == 8900)
13407 {
13408 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);
13409 }
13410
13411 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13412 }
13413
13414 local_free (kernel_lengths);
13415 local_free (kernel_sources[0]);
13416 local_free (kernel_sources);
13417
13418 // this is mostly for debug
13419
13420 size_t ret_val_size = 0;
13421
13422 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13423
13424 if (ret_val_size > 2)
13425 {
13426 char *build_log = (char *) mymalloc (ret_val_size + 1);
13427
13428 memset (build_log, 0, ret_val_size + 1);
13429
13430 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13431
13432 puts (build_log);
13433
13434 myfree (build_log);
13435 }
13436 }
13437
13438 /**
13439 * word generator kernel
13440 */
13441
13442 if (attack_mode != ATTACK_MODE_STRAIGHT)
13443 {
13444 /**
13445 * kernel mp source filename
13446 */
13447
13448 char source_file[256];
13449
13450 memset (source_file, 0, sizeof (source_file));
13451
13452 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13453
13454 struct stat sst;
13455
13456 if (stat (source_file, &sst) == -1)
13457 {
13458 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13459
13460 return -1;
13461 }
13462
13463 /**
13464 * kernel mp cached filename
13465 */
13466
13467 char cached_file[256];
13468
13469 memset (cached_file, 0, sizeof (cached_file));
13470
13471 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13472
13473 int cached = 1;
13474
13475 struct stat cst;
13476
13477 if (stat (cached_file, &cst) == -1)
13478 {
13479 cached = 0;
13480 }
13481
13482 /**
13483 * kernel compile or load
13484 */
13485
13486 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13487
13488 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13489
13490 if (cached == 0)
13491 {
13492 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13493
13494 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13495
13496 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13497
13498 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13499
13500 size_t binary_size;
13501
13502 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13503
13504 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13505
13506 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13507
13508 writeProgramBin (cached_file, binary, binary_size);
13509
13510 local_free (binary);
13511 }
13512 else
13513 {
13514 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13515
13516 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13517
13518 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13519
13520 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13521 }
13522
13523 local_free (kernel_lengths);
13524 local_free (kernel_sources[0]);
13525 local_free (kernel_sources);
13526
13527 // this is mostly for debug
13528
13529 size_t ret_val_size = 0;
13530
13531 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13532
13533 if (ret_val_size > 2)
13534 {
13535 char *build_log = (char *) mymalloc (ret_val_size + 1);
13536
13537 memset (build_log, 0, ret_val_size + 1);
13538
13539 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13540
13541 puts (build_log);
13542
13543 myfree (build_log);
13544 }
13545 }
13546
13547 /**
13548 * amplifier kernel
13549 */
13550
13551 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13552 {
13553
13554 }
13555 else
13556 {
13557 /**
13558 * kernel amp source filename
13559 */
13560
13561 char source_file[256];
13562
13563 memset (source_file, 0, sizeof (source_file));
13564
13565 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13566
13567 struct stat sst;
13568
13569 if (stat (source_file, &sst) == -1)
13570 {
13571 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13572
13573 return -1;
13574 }
13575
13576 /**
13577 * kernel amp cached filename
13578 */
13579
13580 char cached_file[256];
13581
13582 memset (cached_file, 0, sizeof (cached_file));
13583
13584 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13585
13586 int cached = 1;
13587
13588 struct stat cst;
13589
13590 if (stat (cached_file, &cst) == -1)
13591 {
13592 cached = 0;
13593 }
13594
13595 /**
13596 * kernel compile or load
13597 */
13598
13599 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13600
13601 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13602
13603 if (cached == 0)
13604 {
13605 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13606
13607 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13608
13609 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13610
13611 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13612
13613 size_t binary_size;
13614
13615 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13616
13617 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13618
13619 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13620
13621 writeProgramBin (cached_file, binary, binary_size);
13622
13623 local_free (binary);
13624 }
13625 else
13626 {
13627 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13628
13629 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13630
13631 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13632
13633 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13634 }
13635
13636 local_free (kernel_lengths);
13637 local_free (kernel_sources[0]);
13638 local_free (kernel_sources);
13639
13640 // this is mostly for debug
13641
13642 size_t ret_val_size = 0;
13643
13644 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13645
13646 if (ret_val_size > 2)
13647 {
13648 char *build_log = (char *) mymalloc (ret_val_size + 1);
13649
13650 memset (build_log, 0, ret_val_size + 1);
13651
13652 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13653
13654 puts (build_log);
13655
13656 myfree (build_log);
13657 }
13658 }
13659
13660 /**
13661 * global buffers
13662 */
13663
13664 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13665 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13666 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13667 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13668 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13669 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13670 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13671 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13672 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13673 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13674 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13675 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13676 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13677 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13678 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13679 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13680 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13681 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13682
13683 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13684 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13685 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13686 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13687 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13688 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13689 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13690 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13691 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13692 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13693 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13694
13695 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13696 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13697 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13698 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13699 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13700 run_kernel_bzero (device_param, device_param->d_result, size_results);
13701
13702 /**
13703 * special buffers
13704 */
13705
13706 if (attack_kern == ATTACK_KERN_STRAIGHT)
13707 {
13708 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13709 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13710
13711 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13712
13713 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13714 }
13715 else if (attack_kern == ATTACK_KERN_COMBI)
13716 {
13717 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13718 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13719 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13720 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13721
13722 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13723 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13724 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13725 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13726 }
13727 else if (attack_kern == ATTACK_KERN_BF)
13728 {
13729 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13730 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13731 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13732 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13733 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13734
13735 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13736 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13737 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13738 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13739 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13740 }
13741
13742 if (size_esalts)
13743 {
13744 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13745
13746 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13747 }
13748
13749 /**
13750 * main host data
13751 */
13752
13753 uint *result = (uint *) mymalloc (size_results);
13754
13755 memset (result, 0, size_results);
13756
13757 device_param->result = result;
13758
13759 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13760
13761 memset (pws_buf, 0, size_pws);
13762
13763 device_param->pws_buf = pws_buf;
13764
13765 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13766
13767 for (int i = 0; i < 64; i++)
13768 {
13769 pw_caches[i].pw_buf.pw_len = i;
13770 pw_caches[i].cnt = 0;
13771 }
13772
13773 device_param->pw_caches = pw_caches;
13774
13775 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13776
13777 device_param->combs_buf = combs_buf;
13778
13779 void *hooks_buf = mymalloc (size_hooks);
13780
13781 device_param->hooks_buf = hooks_buf;
13782
13783 device_param->pw_transpose = pw_transpose_to_hi1;
13784 device_param->pw_add = pw_add_to_hc1;
13785
13786 /**
13787 * kernel args
13788 */
13789
13790 device_param->kernel_params_buf32[21] = bitmap_mask;
13791 device_param->kernel_params_buf32[22] = bitmap_shift1;
13792 device_param->kernel_params_buf32[23] = bitmap_shift2;
13793 device_param->kernel_params_buf32[24] = 0; // salt_pos
13794 device_param->kernel_params_buf32[25] = 0; // loop_pos
13795 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13796 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13797 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13798 device_param->kernel_params_buf32[29] = 0; // digests_offset
13799 device_param->kernel_params_buf32[30] = 0; // combs_mode
13800 device_param->kernel_params_buf32[31] = 0; // gid_max
13801
13802 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13803 ? &device_param->d_pws_buf
13804 : &device_param->d_pws_amp_buf;
13805 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13806 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13807 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13808 device_param->kernel_params[ 4] = &device_param->d_tmps;
13809 device_param->kernel_params[ 5] = &device_param->d_hooks;
13810 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13811 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13812 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13813 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13814 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13815 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13816 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13817 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13818 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13819 device_param->kernel_params[15] = &device_param->d_digests_buf;
13820 device_param->kernel_params[16] = &device_param->d_digests_shown;
13821 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13822 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13823 device_param->kernel_params[19] = &device_param->d_result;
13824 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13825 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13826 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13827 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13828 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13829 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13830 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13831 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13832 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13833 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13834 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13835 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13836
13837 device_param->kernel_params_mp_buf64[3] = 0;
13838 device_param->kernel_params_mp_buf32[4] = 0;
13839 device_param->kernel_params_mp_buf32[5] = 0;
13840 device_param->kernel_params_mp_buf32[6] = 0;
13841 device_param->kernel_params_mp_buf32[7] = 0;
13842 device_param->kernel_params_mp_buf32[8] = 0;
13843
13844 device_param->kernel_params_mp[0] = NULL;
13845 device_param->kernel_params_mp[1] = NULL;
13846 device_param->kernel_params_mp[2] = NULL;
13847 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13848 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13849 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13850 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13851 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13852 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13853
13854 device_param->kernel_params_mp_l_buf64[3] = 0;
13855 device_param->kernel_params_mp_l_buf32[4] = 0;
13856 device_param->kernel_params_mp_l_buf32[5] = 0;
13857 device_param->kernel_params_mp_l_buf32[6] = 0;
13858 device_param->kernel_params_mp_l_buf32[7] = 0;
13859 device_param->kernel_params_mp_l_buf32[8] = 0;
13860 device_param->kernel_params_mp_l_buf32[9] = 0;
13861
13862 device_param->kernel_params_mp_l[0] = NULL;
13863 device_param->kernel_params_mp_l[1] = NULL;
13864 device_param->kernel_params_mp_l[2] = NULL;
13865 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13866 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13867 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13868 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13869 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13870 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13871 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13872
13873 device_param->kernel_params_mp_r_buf64[3] = 0;
13874 device_param->kernel_params_mp_r_buf32[4] = 0;
13875 device_param->kernel_params_mp_r_buf32[5] = 0;
13876 device_param->kernel_params_mp_r_buf32[6] = 0;
13877 device_param->kernel_params_mp_r_buf32[7] = 0;
13878 device_param->kernel_params_mp_r_buf32[8] = 0;
13879
13880 device_param->kernel_params_mp_r[0] = NULL;
13881 device_param->kernel_params_mp_r[1] = NULL;
13882 device_param->kernel_params_mp_r[2] = NULL;
13883 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
13884 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
13885 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
13886 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
13887 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
13888 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
13889
13890 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
13891 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
13892
13893 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
13894 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
13895 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
13896 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
13897 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
13898 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
13899 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
13900
13901 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
13902
13903 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
13904 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
13905
13906 /**
13907 * kernel name
13908 */
13909
13910 char kernel_name[64];
13911
13912 memset (kernel_name, 0, sizeof (kernel_name));
13913
13914 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13915 {
13916 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13917 {
13918 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
13919
13920 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13921
13922 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
13923
13924 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13925
13926 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
13927
13928 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13929 }
13930 else
13931 {
13932 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
13933
13934 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13935
13936 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
13937
13938 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13939
13940 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
13941
13942 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13943 }
13944
13945 if (data.attack_mode == ATTACK_MODE_BF)
13946 {
13947 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13948 {
13949 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
13950
13951 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
13952
13953 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
13954
13955 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
13956 }
13957 }
13958 }
13959 else
13960 {
13961 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
13962
13963 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13964
13965 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
13966
13967 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13968
13969 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
13970
13971 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13972
13973 if (opts_type & OPTS_TYPE_HOOK12)
13974 {
13975 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
13976
13977 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
13978 }
13979
13980 if (opts_type & OPTS_TYPE_HOOK23)
13981 {
13982 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
13983
13984 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
13985 }
13986 }
13987
13988 for (uint i = 0; i <= 20; i++)
13989 {
13990 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
13991 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
13992 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
13993
13994 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
13995 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
13996 }
13997
13998 for (uint i = 21; i <= 31; i++)
13999 {
14000 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14001 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14002 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14003
14004 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14005 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14006 }
14007
14008 if (attack_mode == ATTACK_MODE_BF)
14009 {
14010 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
14011 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
14012
14013 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14014 {
14015 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14016
14017 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14018 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14019 }
14020 }
14021 else if (attack_mode == ATTACK_MODE_HYBRID1)
14022 {
14023 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14024 }
14025 else if (attack_mode == ATTACK_MODE_HYBRID2)
14026 {
14027 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14028 }
14029
14030 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14031 {
14032 // nothing to do
14033 }
14034 else
14035 {
14036 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14037 }
14038
14039 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14040 {
14041 // nothing to do
14042 }
14043 else
14044 {
14045 for (uint i = 0; i < 5; i++)
14046 {
14047 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14048 }
14049
14050 for (uint i = 5; i < 7; i++)
14051 {
14052 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14053 }
14054 }
14055
14056 /**
14057 * Store initial fanspeed if gpu_temp_retain is enabled
14058 */
14059
14060 int gpu_temp_retain_set = 0;
14061
14062 if (gpu_temp_disable == 0)
14063 {
14064 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14065 {
14066 hc_thread_mutex_lock (mux_adl);
14067
14068 if (data.hm_device[device_id].fan_supported == 1)
14069 {
14070 if (gpu_temp_retain_chgd == 0)
14071 {
14072 uint cur_temp = 0;
14073 uint default_temp = 0;
14074
14075 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);
14076
14077 if (ADL_rc == ADL_OK)
14078 {
14079 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14080
14081 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14082
14083 // special case with multi gpu setups: always use minimum retain
14084
14085 if (gpu_temp_retain_set == 0)
14086 {
14087 gpu_temp_retain = gpu_temp_retain_target;
14088 gpu_temp_retain_set = 1;
14089 }
14090 else
14091 {
14092 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14093 }
14094
14095 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14096 }
14097 }
14098
14099 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14100
14101 temp_retain_fanspeed_value[device_id] = fan_speed;
14102
14103 if (fan_speed == -1)
14104 {
14105 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14106
14107 temp_retain_fanspeed_value[device_id] = 0;
14108 }
14109 }
14110
14111 hc_thread_mutex_unlock (mux_adl);
14112 }
14113 }
14114
14115 /**
14116 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14117 */
14118
14119 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14120 {
14121 hc_thread_mutex_lock (mux_adl);
14122
14123 if (data.hm_device[device_id].od_version == 6)
14124 {
14125 int ADL_rc;
14126
14127 // check powertune capabilities first, if not available then skip device
14128
14129 int powertune_supported = 0;
14130
14131 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14132 {
14133 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14134
14135 return (-1);
14136 }
14137
14138 if (powertune_supported != 0)
14139 {
14140 // powercontrol settings
14141
14142 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14143
14144 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14145 {
14146 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]);
14147 }
14148
14149 if (ADL_rc != ADL_OK)
14150 {
14151 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14152
14153 return (-1);
14154 }
14155
14156 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14157 {
14158 log_error ("ERROR: Failed to set new ADL PowerControl values");
14159
14160 return (-1);
14161 }
14162
14163 // clocks
14164
14165 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14166
14167 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14168
14169 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)
14170 {
14171 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14172
14173 return (-1);
14174 }
14175
14176 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14177
14178 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14179
14180 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14181 {
14182 log_error ("ERROR: Failed to get ADL device capabilities");
14183
14184 return (-1);
14185 }
14186
14187 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14188 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14189
14190 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14191 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14192
14193 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14194 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14195
14196 // warning if profile has to low max values
14197
14198 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14199 {
14200 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14201 }
14202
14203 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14204 {
14205 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14206 }
14207
14208 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14209
14210 performance_state->iNumberOfPerformanceLevels = 2;
14211
14212 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14213 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14214 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14215 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14216
14217 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)
14218 {
14219 log_info ("ERROR: Failed to set ADL performance state");
14220
14221 return (-1);
14222 }
14223
14224 local_free (performance_state);
14225 }
14226 }
14227
14228 hc_thread_mutex_unlock (mux_adl);
14229 }
14230 }
14231
14232 data.kernel_blocks_all = kernel_blocks_all;
14233
14234 if (data.quiet == 0) log_info ("");
14235
14236 /**
14237 * Inform user which algorithm is checked and at which workload setting
14238 */
14239
14240 if (benchmark == 1)
14241 {
14242 quiet = 0;
14243
14244 data.quiet = quiet;
14245
14246 char *hash_type = strhashtype (data.hash_mode); // not a bug
14247
14248 log_info ("Hashtype: %s", hash_type);
14249 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14250 log_info ("");
14251 }
14252
14253 /**
14254 * keep track of the progress
14255 */
14256
14257 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14258 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14259 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14260
14261 /**
14262 * open filehandles
14263 */
14264
14265 #if _WIN
14266 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14267 {
14268 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14269
14270 return (-1);
14271 }
14272
14273 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14274 {
14275 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14276
14277 return (-1);
14278 }
14279
14280 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14281 {
14282 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14283
14284 return (-1);
14285 }
14286 #endif
14287
14288 /**
14289 * dictionary pad
14290 */
14291
14292 segment_size *= (1024 * 1024);
14293
14294 data.segment_size = segment_size;
14295
14296 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14297
14298 wl_data->buf = (char *) mymalloc (segment_size);
14299 wl_data->avail = segment_size;
14300 wl_data->incr = segment_size;
14301 wl_data->cnt = 0;
14302 wl_data->pos = 0;
14303
14304 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14305
14306 data.wordlist_mode = wordlist_mode;
14307
14308 cs_t *css_buf = NULL;
14309 uint css_cnt = 0;
14310 uint dictcnt = 0;
14311 uint maskcnt = 1;
14312 char **masks = NULL;
14313 char **dictfiles = NULL;
14314
14315 uint mask_from_file = 0;
14316
14317 if (attack_mode == ATTACK_MODE_STRAIGHT)
14318 {
14319 if (wordlist_mode == WL_MODE_FILE)
14320 {
14321 int wls_left = myargc - (optind + 1);
14322
14323 for (int i = 0; i < wls_left; i++)
14324 {
14325 char *l0_filename = myargv[optind + 1 + i];
14326
14327 struct stat l0_stat;
14328
14329 if (stat (l0_filename, &l0_stat) == -1)
14330 {
14331 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14332
14333 return (-1);
14334 }
14335
14336 uint is_dir = S_ISDIR (l0_stat.st_mode);
14337
14338 if (is_dir == 0)
14339 {
14340 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14341
14342 dictcnt++;
14343
14344 dictfiles[dictcnt - 1] = l0_filename;
14345 }
14346 else
14347 {
14348 // do not allow --keyspace w/ a directory
14349
14350 if (keyspace == 1)
14351 {
14352 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14353
14354 return (-1);
14355 }
14356
14357 char **dictionary_files = NULL;
14358
14359 dictionary_files = scan_directory (l0_filename);
14360
14361 if (dictionary_files != NULL)
14362 {
14363 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14364
14365 for (int d = 0; dictionary_files[d] != NULL; d++)
14366 {
14367 char *l1_filename = dictionary_files[d];
14368
14369 struct stat l1_stat;
14370
14371 if (stat (l1_filename, &l1_stat) == -1)
14372 {
14373 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14374
14375 return (-1);
14376 }
14377
14378 if (S_ISREG (l1_stat.st_mode))
14379 {
14380 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14381
14382 dictcnt++;
14383
14384 dictfiles[dictcnt - 1] = strdup (l1_filename);
14385 }
14386 }
14387 }
14388
14389 local_free (dictionary_files);
14390 }
14391 }
14392
14393 if (dictcnt < 1)
14394 {
14395 log_error ("ERROR: No usable dictionary file found.");
14396
14397 return (-1);
14398 }
14399 }
14400 else if (wordlist_mode == WL_MODE_STDIN)
14401 {
14402 dictcnt = 1;
14403 }
14404 }
14405 else if (attack_mode == ATTACK_MODE_COMBI)
14406 {
14407 // display
14408
14409 char *dictfile1 = myargv[optind + 1 + 0];
14410 char *dictfile2 = myargv[optind + 1 + 1];
14411
14412 // find the bigger dictionary and use as base
14413
14414 FILE *fp1;
14415 FILE *fp2;
14416
14417 struct stat tmp_stat;
14418
14419 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14420 {
14421 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14422
14423 return (-1);
14424 }
14425
14426 if (stat (dictfile1, &tmp_stat) == -1)
14427 {
14428 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14429
14430 fclose (fp1);
14431
14432 return (-1);
14433 }
14434
14435 if (S_ISDIR (tmp_stat.st_mode))
14436 {
14437 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14438
14439 fclose (fp1);
14440
14441 return (-1);
14442 }
14443
14444 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14445 {
14446 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14447
14448 fclose (fp1);
14449
14450 return (-1);
14451 }
14452
14453 if (stat (dictfile2, &tmp_stat) == -1)
14454 {
14455 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14456
14457 fclose (fp1);
14458 fclose (fp2);
14459
14460 return (-1);
14461 }
14462
14463 if (S_ISDIR (tmp_stat.st_mode))
14464 {
14465 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14466
14467 fclose (fp1);
14468 fclose (fp2);
14469
14470 return (-1);
14471 }
14472
14473 data.combs_cnt = 1;
14474
14475 data.quiet = 1;
14476
14477 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14478
14479 data.quiet = quiet;
14480
14481 if (words1_cnt == 0)
14482 {
14483 log_error ("ERROR: %s: empty file", dictfile1);
14484
14485 fclose (fp1);
14486 fclose (fp2);
14487
14488 return (-1);
14489 }
14490
14491 data.combs_cnt = 1;
14492
14493 data.quiet = 1;
14494
14495 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14496
14497 data.quiet = quiet;
14498
14499 if (words2_cnt == 0)
14500 {
14501 log_error ("ERROR: %s: empty file", dictfile2);
14502
14503 fclose (fp1);
14504 fclose (fp2);
14505
14506 return (-1);
14507 }
14508
14509 fclose (fp1);
14510 fclose (fp2);
14511
14512 data.dictfile = dictfile1;
14513 data.dictfile2 = dictfile2;
14514
14515 if (words1_cnt >= words2_cnt)
14516 {
14517 data.combs_cnt = words2_cnt;
14518 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14519
14520 dictfiles = &data.dictfile;
14521
14522 dictcnt = 1;
14523 }
14524 else
14525 {
14526 data.combs_cnt = words1_cnt;
14527 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14528
14529 dictfiles = &data.dictfile2;
14530
14531 dictcnt = 1;
14532
14533 // we also have to switch wordlist related rules!
14534
14535 char *tmpc = data.rule_buf_l;
14536
14537 data.rule_buf_l = data.rule_buf_r;
14538 data.rule_buf_r = tmpc;
14539
14540 int tmpi = data.rule_len_l;
14541
14542 data.rule_len_l = data.rule_len_r;
14543 data.rule_len_r = tmpi;
14544 }
14545 }
14546 else if (attack_mode == ATTACK_MODE_BF)
14547 {
14548 char *mask = NULL;
14549
14550 maskcnt = 0;
14551
14552 if (benchmark == 0)
14553 {
14554 mask = myargv[optind + 1];
14555
14556 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14557
14558 if ((optind + 2) <= myargc)
14559 {
14560 struct stat file_stat;
14561
14562 if (stat (mask, &file_stat) == -1)
14563 {
14564 maskcnt = 1;
14565
14566 masks[maskcnt - 1] = mystrdup (mask);
14567 }
14568 else
14569 {
14570 int wls_left = myargc - (optind + 1);
14571
14572 uint masks_avail = INCR_MASKS;
14573
14574 for (int i = 0; i < wls_left; i++)
14575 {
14576 if (i != 0)
14577 {
14578 mask = myargv[optind + 1 + i];
14579
14580 if (stat (mask, &file_stat) == -1)
14581 {
14582 log_error ("ERROR: %s: %s", mask, strerror (errno));
14583
14584 return (-1);
14585 }
14586 }
14587
14588 uint is_file = S_ISREG (file_stat.st_mode);
14589
14590 if (is_file == 1)
14591 {
14592 FILE *mask_fp;
14593
14594 if ((mask_fp = fopen (mask, "r")) == NULL)
14595 {
14596 log_error ("ERROR: %s: %s", mask, strerror (errno));
14597
14598 return (-1);
14599 }
14600
14601 char line_buf[BUFSIZ];
14602
14603 while (!feof (mask_fp))
14604 {
14605 memset (line_buf, 0, BUFSIZ);
14606
14607 int line_len = fgetl (mask_fp, line_buf);
14608
14609 if (line_len == 0) continue;
14610
14611 if (line_buf[0] == '#') continue;
14612
14613 if (masks_avail == maskcnt)
14614 {
14615 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14616
14617 masks_avail += INCR_MASKS;
14618 }
14619
14620 masks[maskcnt] = mystrdup (line_buf);
14621
14622 maskcnt++;
14623 }
14624
14625 fclose (mask_fp);
14626 }
14627 else
14628 {
14629 log_error ("ERROR: %s: unsupported file-type", mask);
14630
14631 return (-1);
14632 }
14633 }
14634
14635 mask_from_file = 1;
14636 }
14637 }
14638 else
14639 {
14640 custom_charset_1 = (char *) "?l?d?u";
14641 custom_charset_2 = (char *) "?l?d";
14642 custom_charset_3 = (char *) "?l?d*!$@_";
14643
14644 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14645 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14646 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14647
14648 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14649
14650 wordlist_mode = WL_MODE_MASK;
14651
14652 data.wordlist_mode = wordlist_mode;
14653
14654 increment = 1;
14655
14656 maskcnt = 1;
14657 }
14658 }
14659 else
14660 {
14661 /**
14662 * generate full masks and charsets
14663 */
14664
14665 masks = (char **) mymalloc (sizeof (char *));
14666
14667 switch (hash_mode)
14668 {
14669 case 1731: pw_min = 5;
14670 pw_max = 5;
14671 mask = mystrdup ("?b?b?b?b?b");
14672 break;
14673 case 12500: pw_min = 5;
14674 pw_max = 5;
14675 mask = mystrdup ("?b?b?b?b?b");
14676 break;
14677 default: pw_min = 7;
14678 pw_max = 7;
14679 mask = mystrdup ("?b?b?b?b?b?b?b");
14680 break;
14681 }
14682
14683 maskcnt = 1;
14684
14685 masks[maskcnt - 1] = mystrdup (mask);
14686
14687 wordlist_mode = WL_MODE_MASK;
14688
14689 data.wordlist_mode = wordlist_mode;
14690
14691 increment = 1;
14692 }
14693
14694 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14695
14696 if (increment)
14697 {
14698 if (increment_min > pw_min) pw_min = increment_min;
14699
14700 if (increment_max < pw_max) pw_max = increment_max;
14701 }
14702 }
14703 else if (attack_mode == ATTACK_MODE_HYBRID1)
14704 {
14705 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14706
14707 // display
14708
14709 char *mask = myargv[myargc - 1];
14710
14711 maskcnt = 0;
14712
14713 masks = (char **) mymalloc (1 * sizeof (char *));
14714
14715 // mod
14716
14717 struct stat file_stat;
14718
14719 if (stat (mask, &file_stat) == -1)
14720 {
14721 maskcnt = 1;
14722
14723 masks[maskcnt - 1] = mystrdup (mask);
14724 }
14725 else
14726 {
14727 uint is_file = S_ISREG (file_stat.st_mode);
14728
14729 if (is_file == 1)
14730 {
14731 FILE *mask_fp;
14732
14733 if ((mask_fp = fopen (mask, "r")) == NULL)
14734 {
14735 log_error ("ERROR: %s: %s", mask, strerror (errno));
14736
14737 return (-1);
14738 }
14739
14740 char line_buf[BUFSIZ];
14741
14742 uint masks_avail = 1;
14743
14744 while (!feof (mask_fp))
14745 {
14746 memset (line_buf, 0, BUFSIZ);
14747
14748 int line_len = fgetl (mask_fp, line_buf);
14749
14750 if (line_len == 0) continue;
14751
14752 if (line_buf[0] == '#') continue;
14753
14754 if (masks_avail == maskcnt)
14755 {
14756 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14757
14758 masks_avail += INCR_MASKS;
14759 }
14760
14761 masks[maskcnt] = mystrdup (line_buf);
14762
14763 maskcnt++;
14764 }
14765
14766 fclose (mask_fp);
14767
14768 mask_from_file = 1;
14769 }
14770 else
14771 {
14772 maskcnt = 1;
14773
14774 masks[maskcnt - 1] = mystrdup (mask);
14775 }
14776 }
14777
14778 // base
14779
14780 int wls_left = myargc - (optind + 2);
14781
14782 for (int i = 0; i < wls_left; i++)
14783 {
14784 char *filename = myargv[optind + 1 + i];
14785
14786 struct stat file_stat;
14787
14788 if (stat (filename, &file_stat) == -1)
14789 {
14790 log_error ("ERROR: %s: %s", filename, strerror (errno));
14791
14792 return (-1);
14793 }
14794
14795 uint is_dir = S_ISDIR (file_stat.st_mode);
14796
14797 if (is_dir == 0)
14798 {
14799 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14800
14801 dictcnt++;
14802
14803 dictfiles[dictcnt - 1] = filename;
14804 }
14805 else
14806 {
14807 // do not allow --keyspace w/ a directory
14808
14809 if (keyspace == 1)
14810 {
14811 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14812
14813 return (-1);
14814 }
14815
14816 char **dictionary_files = NULL;
14817
14818 dictionary_files = scan_directory (filename);
14819
14820 if (dictionary_files != NULL)
14821 {
14822 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14823
14824 for (int d = 0; dictionary_files[d] != NULL; d++)
14825 {
14826 char *l1_filename = dictionary_files[d];
14827
14828 struct stat l1_stat;
14829
14830 if (stat (l1_filename, &l1_stat) == -1)
14831 {
14832 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14833
14834 return (-1);
14835 }
14836
14837 if (S_ISREG (l1_stat.st_mode))
14838 {
14839 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14840
14841 dictcnt++;
14842
14843 dictfiles[dictcnt - 1] = strdup (l1_filename);
14844 }
14845 }
14846 }
14847
14848 local_free (dictionary_files);
14849 }
14850 }
14851
14852 if (dictcnt < 1)
14853 {
14854 log_error ("ERROR: No usable dictionary file found.");
14855
14856 return (-1);
14857 }
14858
14859 if (increment)
14860 {
14861 maskcnt = 0;
14862
14863 uint mask_min = increment_min; // we can't reject smaller masks here
14864 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14865
14866 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14867 {
14868 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14869
14870 if (cur_mask == NULL) break;
14871
14872 masks[maskcnt] = cur_mask;
14873
14874 maskcnt++;
14875
14876 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14877 }
14878 }
14879 }
14880 else if (attack_mode == ATTACK_MODE_HYBRID2)
14881 {
14882 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14883
14884 // display
14885
14886 char *mask = myargv[optind + 1 + 0];
14887
14888 maskcnt = 0;
14889
14890 masks = (char **) mymalloc (1 * sizeof (char *));
14891
14892 // mod
14893
14894 struct stat file_stat;
14895
14896 if (stat (mask, &file_stat) == -1)
14897 {
14898 maskcnt = 1;
14899
14900 masks[maskcnt - 1] = mystrdup (mask);
14901 }
14902 else
14903 {
14904 uint is_file = S_ISREG (file_stat.st_mode);
14905
14906 if (is_file == 1)
14907 {
14908 FILE *mask_fp;
14909
14910 if ((mask_fp = fopen (mask, "r")) == NULL)
14911 {
14912 log_error ("ERROR: %s: %s", mask, strerror (errno));
14913
14914 return (-1);
14915 }
14916
14917 char line_buf[BUFSIZ];
14918
14919 uint masks_avail = 1;
14920
14921 while (!feof (mask_fp))
14922 {
14923 memset (line_buf, 0, BUFSIZ);
14924
14925 int line_len = fgetl (mask_fp, line_buf);
14926
14927 if (line_len == 0) continue;
14928
14929 if (line_buf[0] == '#') continue;
14930
14931 if (masks_avail == maskcnt)
14932 {
14933 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14934
14935 masks_avail += INCR_MASKS;
14936 }
14937
14938 masks[maskcnt] = mystrdup (line_buf);
14939
14940 maskcnt++;
14941 }
14942
14943 fclose (mask_fp);
14944
14945 mask_from_file = 1;
14946 }
14947 else
14948 {
14949 maskcnt = 1;
14950
14951 masks[maskcnt - 1] = mystrdup (mask);
14952 }
14953 }
14954
14955 // base
14956
14957 int wls_left = myargc - (optind + 2);
14958
14959 for (int i = 0; i < wls_left; i++)
14960 {
14961 char *filename = myargv[optind + 2 + i];
14962
14963 struct stat file_stat;
14964
14965 if (stat (filename, &file_stat) == -1)
14966 {
14967 log_error ("ERROR: %s: %s", filename, strerror (errno));
14968
14969 return (-1);
14970 }
14971
14972 uint is_dir = S_ISDIR (file_stat.st_mode);
14973
14974 if (is_dir == 0)
14975 {
14976 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14977
14978 dictcnt++;
14979
14980 dictfiles[dictcnt - 1] = filename;
14981 }
14982 else
14983 {
14984 // do not allow --keyspace w/ a directory
14985
14986 if (keyspace == 1)
14987 {
14988 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14989
14990 return (-1);
14991 }
14992
14993 char **dictionary_files = NULL;
14994
14995 dictionary_files = scan_directory (filename);
14996
14997 if (dictionary_files != NULL)
14998 {
14999 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15000
15001 for (int d = 0; dictionary_files[d] != NULL; d++)
15002 {
15003 char *l1_filename = dictionary_files[d];
15004
15005 struct stat l1_stat;
15006
15007 if (stat (l1_filename, &l1_stat) == -1)
15008 {
15009 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15010
15011 return (-1);
15012 }
15013
15014 if (S_ISREG (l1_stat.st_mode))
15015 {
15016 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15017
15018 dictcnt++;
15019
15020 dictfiles[dictcnt - 1] = strdup (l1_filename);
15021 }
15022 }
15023 }
15024
15025 local_free (dictionary_files);
15026 }
15027 }
15028
15029 if (dictcnt < 1)
15030 {
15031 log_error ("ERROR: No usable dictionary file found.");
15032
15033 return (-1);
15034 }
15035
15036 if (increment)
15037 {
15038 maskcnt = 0;
15039
15040 uint mask_min = increment_min; // we can't reject smaller masks here
15041 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15042
15043 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15044 {
15045 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15046
15047 if (cur_mask == NULL) break;
15048
15049 masks[maskcnt] = cur_mask;
15050
15051 maskcnt++;
15052
15053 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15054 }
15055 }
15056 }
15057
15058 data.pw_min = pw_min;
15059 data.pw_max = pw_max;
15060
15061 /**
15062 * weak hash check
15063 */
15064
15065 if (weak_hash_threshold >= salts_cnt)
15066 {
15067 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15068
15069 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15070 {
15071 weak_hash_check (&data.devices_param[0], salt_pos, kernel_loops);
15072 }
15073 }
15074
15075 // Display hack, guarantee that there is at least one \r before real start
15076
15077 if (data.quiet == 0) log_info_nn ("");
15078
15079 /**
15080 * status and monitor threads
15081 */
15082
15083 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15084
15085 hc_thread_t i_thread = 0;
15086
15087 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15088 {
15089 hc_thread_create (i_thread, thread_keypress, &benchmark);
15090 }
15091
15092 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15093
15094 uint ni_threads_cnt = 0;
15095
15096 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15097
15098 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15099
15100 ni_threads_cnt++;
15101
15102 /**
15103 * Outfile remove
15104 */
15105
15106 if (keyspace == 0)
15107 {
15108 if (outfile_check_timer != 0)
15109 {
15110 if (data.outfile_check_directory != NULL)
15111 {
15112 if ((hash_mode != 5200) &&
15113 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15114 (hash_mode != 9000))
15115 {
15116 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15117
15118 ni_threads_cnt++;
15119 }
15120 else
15121 {
15122 outfile_check_timer = 0;
15123 }
15124 }
15125 else
15126 {
15127 outfile_check_timer = 0;
15128 }
15129 }
15130 }
15131
15132 /**
15133 * Inform the user if we got some hashes remove because of the pot file remove feature
15134 */
15135
15136 if (data.quiet == 0)
15137 {
15138 if (potfile_remove_cracks > 0)
15139 {
15140 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15141 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15142 }
15143 }
15144
15145 data.outfile_check_timer = outfile_check_timer;
15146
15147 /**
15148 * main loop
15149 */
15150
15151 char **induction_dictionaries = NULL;
15152
15153 int induction_dictionaries_cnt = 0;
15154
15155 hcstat_table_t *root_table_buf = NULL;
15156 hcstat_table_t *markov_table_buf = NULL;
15157
15158 uint initial_restore_done = 0;
15159
15160 data.maskcnt = maskcnt;
15161
15162 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15163 {
15164 if (data.devices_status == STATUS_CRACKED) break;
15165
15166 data.devices_status = STATUS_INIT;
15167
15168 if (maskpos > rd->maskpos)
15169 {
15170 rd->dictpos = 0;
15171 }
15172
15173 rd->maskpos = maskpos;
15174 data.maskpos = maskpos;
15175
15176 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15177 {
15178 char *mask = masks[maskpos];
15179
15180 if (mask_from_file == 1)
15181 {
15182 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15183
15184 char *str_ptr;
15185 uint str_pos;
15186
15187 uint mask_offset = 0;
15188
15189 uint separator_cnt;
15190
15191 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15192 {
15193 str_ptr = strstr (mask + mask_offset, ",");
15194
15195 if (str_ptr == NULL) break;
15196
15197 str_pos = str_ptr - mask;
15198
15199 // escaped separator, i.e. "\,"
15200
15201 if (str_pos > 0)
15202 {
15203 if (mask[str_pos - 1] == '\\')
15204 {
15205 separator_cnt --;
15206
15207 mask_offset = str_pos + 1;
15208
15209 continue;
15210 }
15211 }
15212
15213 // reset the offset
15214
15215 mask_offset = 0;
15216
15217 mask[str_pos] = '\0';
15218
15219 switch (separator_cnt)
15220 {
15221 case 0:
15222 mp_reset_usr (mp_usr, 0);
15223
15224 custom_charset_1 = mask;
15225 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15226 break;
15227
15228 case 1:
15229 mp_reset_usr (mp_usr, 1);
15230
15231 custom_charset_2 = mask;
15232 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15233 break;
15234
15235 case 2:
15236 mp_reset_usr (mp_usr, 2);
15237
15238 custom_charset_3 = mask;
15239 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15240 break;
15241
15242 case 3:
15243 mp_reset_usr (mp_usr, 3);
15244
15245 custom_charset_4 = mask;
15246 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15247 break;
15248 }
15249
15250 mask = mask + str_pos + 1;
15251 }
15252 }
15253
15254 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15255 {
15256 if (maskpos > 0)
15257 {
15258 local_free (css_buf);
15259 local_free (data.root_css_buf);
15260 local_free (data.markov_css_buf);
15261
15262 local_free (masks[maskpos - 1]);
15263 }
15264
15265 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15266
15267 data.mask = mask;
15268 data.css_cnt = css_cnt;
15269 data.css_buf = css_buf;
15270
15271 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15272
15273 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15274
15275 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15276
15277 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15278 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15279
15280 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15281
15282 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15283
15284 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15285 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15286
15287 data.root_css_buf = root_css_buf;
15288 data.markov_css_buf = markov_css_buf;
15289
15290 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15291
15292 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15293
15294 local_free (root_table_buf);
15295 local_free (markov_table_buf);
15296
15297 // args
15298
15299 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15300 {
15301 hc_device_param_t *device_param = &data.devices_param[device_id];
15302
15303 device_param->kernel_params_mp[0] = &device_param->d_combs;
15304 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15305 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15306
15307 device_param->kernel_params_mp_buf64[3] = 0;
15308 device_param->kernel_params_mp_buf32[4] = css_cnt;
15309 device_param->kernel_params_mp_buf32[5] = 0;
15310 device_param->kernel_params_mp_buf32[6] = 0;
15311 device_param->kernel_params_mp_buf32[7] = 0;
15312
15313 if (attack_mode == ATTACK_MODE_HYBRID1)
15314 {
15315 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15316 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15317 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15318 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15319 }
15320 else if (attack_mode == ATTACK_MODE_HYBRID2)
15321 {
15322 device_param->kernel_params_mp_buf32[5] = 0;
15323 device_param->kernel_params_mp_buf32[6] = 0;
15324 device_param->kernel_params_mp_buf32[7] = 0;
15325 }
15326
15327 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15328 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15329 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15330
15331 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);
15332 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);
15333 }
15334 }
15335 else if (attack_mode == ATTACK_MODE_BF)
15336 {
15337 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15338
15339 if (increment)
15340 {
15341 for (uint i = 0; i < dictcnt; i++)
15342 {
15343 local_free (dictfiles[i]);
15344 }
15345
15346 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15347 {
15348 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15349
15350 if (l1_filename == NULL) break;
15351
15352 dictcnt++;
15353
15354 dictfiles[dictcnt - 1] = l1_filename;
15355 }
15356 }
15357 else
15358 {
15359 dictcnt++;
15360
15361 dictfiles[dictcnt - 1] = mask;
15362 }
15363
15364 if (dictcnt == 0)
15365 {
15366 log_error ("ERROR: Mask is too small");
15367
15368 return (-1);
15369 }
15370 }
15371 }
15372
15373 free (induction_dictionaries);
15374
15375 // induction_dictionaries_cnt = 0; // implied
15376
15377 if (attack_mode != ATTACK_MODE_BF)
15378 {
15379 if (keyspace == 0)
15380 {
15381 induction_dictionaries = scan_directory (induction_directory);
15382
15383 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15384 }
15385 }
15386
15387 if (induction_dictionaries_cnt)
15388 {
15389 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15390 }
15391
15392 /**
15393 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15394 */
15395 if (keyspace == 1)
15396 {
15397 if ((maskcnt > 1) || (dictcnt > 1))
15398 {
15399 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15400
15401 return (-1);
15402 }
15403 }
15404
15405 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15406 {
15407 char *subid = logfile_generate_subid ();
15408
15409 data.subid = subid;
15410
15411 logfile_sub_msg ("START");
15412
15413 data.devices_status = STATUS_INIT;
15414
15415 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15416 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15417 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15418
15419 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15420
15421 data.cpt_pos = 0;
15422
15423 data.cpt_start = time (NULL);
15424
15425 data.cpt_total = 0;
15426
15427 if (data.restore == 0)
15428 {
15429 rd->words_cur = skip;
15430
15431 skip = 0;
15432
15433 data.skip = 0;
15434 }
15435
15436 data.ms_paused = 0;
15437
15438 data.words_cur = rd->words_cur;
15439
15440 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15441 {
15442 hc_device_param_t *device_param = &data.devices_param[device_id];
15443
15444 device_param->speed_pos = 0;
15445
15446 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15447 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15448 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15449
15450 device_param->kernel_power = device_param->kernel_power_user;
15451 device_param->kernel_blocks = device_param->kernel_blocks_user;
15452
15453 device_param->outerloop_pos = 0;
15454 device_param->outerloop_left = 0;
15455 device_param->innerloop_pos = 0;
15456 device_param->innerloop_left = 0;
15457
15458 // some more resets:
15459
15460 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15461
15462 memset (device_param->pws_buf, 0, device_param->size_pws);
15463
15464 device_param->pw_cnt = 0;
15465 device_param->pws_cnt = 0;
15466
15467 device_param->words_off = 0;
15468 device_param->words_done = 0;
15469 }
15470
15471 data.kernel_blocks_div = 0;
15472
15473 // figure out some workload
15474
15475 if (attack_mode == ATTACK_MODE_STRAIGHT)
15476 {
15477 if (data.wordlist_mode == WL_MODE_FILE)
15478 {
15479 char *dictfile = NULL;
15480
15481 if (induction_dictionaries_cnt)
15482 {
15483 dictfile = induction_dictionaries[0];
15484 }
15485 else
15486 {
15487 dictfile = dictfiles[dictpos];
15488 }
15489
15490 data.dictfile = dictfile;
15491
15492 logfile_sub_string (dictfile);
15493
15494 for (uint i = 0; i < rp_files_cnt; i++)
15495 {
15496 logfile_sub_var_string ("rulefile", rp_files[i]);
15497 }
15498
15499 FILE *fd2 = fopen (dictfile, "rb");
15500
15501 if (fd2 == NULL)
15502 {
15503 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15504
15505 return (-1);
15506 }
15507
15508 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15509
15510 fclose (fd2);
15511
15512 if (data.words_cnt == 0)
15513 {
15514 if (data.devices_status == STATUS_CRACKED) break;
15515 if (data.devices_status == STATUS_ABORTED) break;
15516
15517 dictpos++;
15518
15519 continue;
15520 }
15521 }
15522 }
15523 else if (attack_mode == ATTACK_MODE_COMBI)
15524 {
15525 char *dictfile = data.dictfile;
15526 char *dictfile2 = data.dictfile2;
15527
15528 logfile_sub_string (dictfile);
15529 logfile_sub_string (dictfile2);
15530
15531 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15532 {
15533 FILE *fd2 = fopen (dictfile, "rb");
15534
15535 if (fd2 == NULL)
15536 {
15537 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15538
15539 return (-1);
15540 }
15541
15542 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15543
15544 fclose (fd2);
15545 }
15546 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15547 {
15548 FILE *fd2 = fopen (dictfile2, "rb");
15549
15550 if (fd2 == NULL)
15551 {
15552 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15553
15554 return (-1);
15555 }
15556
15557 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15558
15559 fclose (fd2);
15560 }
15561
15562 if (data.words_cnt == 0)
15563 {
15564 if (data.devices_status == STATUS_CRACKED) break;
15565 if (data.devices_status == STATUS_ABORTED) break;
15566
15567 dictpos++;
15568
15569 continue;
15570 }
15571 }
15572 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15573 {
15574 char *dictfile = NULL;
15575
15576 if (induction_dictionaries_cnt)
15577 {
15578 dictfile = induction_dictionaries[0];
15579 }
15580 else
15581 {
15582 dictfile = dictfiles[dictpos];
15583 }
15584
15585 data.dictfile = dictfile;
15586
15587 char *mask = data.mask;
15588
15589 logfile_sub_string (dictfile);
15590 logfile_sub_string (mask);
15591
15592 FILE *fd2 = fopen (dictfile, "rb");
15593
15594 if (fd2 == NULL)
15595 {
15596 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15597
15598 return (-1);
15599 }
15600
15601 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15602
15603 fclose (fd2);
15604
15605 if (data.words_cnt == 0)
15606 {
15607 if (data.devices_status == STATUS_CRACKED) break;
15608 if (data.devices_status == STATUS_ABORTED) break;
15609
15610 dictpos++;
15611
15612 continue;
15613 }
15614 }
15615 else if (attack_mode == ATTACK_MODE_BF)
15616 {
15617 local_free (css_buf);
15618 local_free (data.root_css_buf);
15619 local_free (data.markov_css_buf);
15620
15621 char *mask = dictfiles[dictpos];
15622
15623 logfile_sub_string (mask);
15624
15625 // base
15626
15627 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15628
15629 if (opts_type & OPTS_TYPE_PT_UNICODE)
15630 {
15631 uint css_cnt_unicode = css_cnt * 2;
15632
15633 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15634
15635 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15636 {
15637 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15638
15639 css_buf_unicode[j + 1].cs_buf[0] = 0;
15640 css_buf_unicode[j + 1].cs_len = 1;
15641 }
15642
15643 free (css_buf);
15644
15645 css_buf = css_buf_unicode;
15646 css_cnt = css_cnt_unicode;
15647 }
15648
15649 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15650
15651 uint mask_min = pw_min;
15652 uint mask_max = pw_max;
15653
15654 if (opts_type & OPTS_TYPE_PT_UNICODE)
15655 {
15656 mask_min *= 2;
15657 mask_max *= 2;
15658 }
15659
15660 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15661 {
15662 if (css_cnt < mask_min)
15663 {
15664 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15665 }
15666
15667 if (css_cnt > mask_max)
15668 {
15669 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15670 }
15671
15672 // skip to next mask
15673
15674 dictpos++;
15675
15676 rd->dictpos = dictpos;
15677
15678 logfile_sub_msg ("STOP");
15679
15680 continue;
15681 }
15682
15683 uint save_css_cnt = css_cnt;
15684
15685 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15686 {
15687 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15688 {
15689 uint salt_len = (uint) data.salts_buf[0].salt_len;
15690 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15691
15692 uint css_cnt_salt = css_cnt + salt_len;
15693
15694 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15695
15696 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15697
15698 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15699 {
15700 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15701 css_buf_salt[j].cs_len = 1;
15702 }
15703
15704 free (css_buf);
15705
15706 css_buf = css_buf_salt;
15707 css_cnt = css_cnt_salt;
15708 }
15709 }
15710
15711 data.mask = mask;
15712 data.css_cnt = css_cnt;
15713 data.css_buf = css_buf;
15714
15715 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15716
15717 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15718
15719 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15720
15721 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15722
15723 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15724 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15725
15726 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15727
15728 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15729
15730 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15731 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15732
15733 data.root_css_buf = root_css_buf;
15734 data.markov_css_buf = markov_css_buf;
15735
15736 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15737
15738 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15739
15740 local_free (root_table_buf);
15741 local_free (markov_table_buf);
15742
15743 // copy + args
15744
15745 uint css_cnt_l = css_cnt;
15746 uint css_cnt_r;
15747
15748 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15749 {
15750 if (save_css_cnt < 6)
15751 {
15752 css_cnt_r = 1;
15753 }
15754 else if (save_css_cnt == 6)
15755 {
15756 css_cnt_r = 2;
15757 }
15758 else
15759 {
15760 if (opts_type & OPTS_TYPE_PT_UNICODE)
15761 {
15762 if (save_css_cnt == 8 || save_css_cnt == 10)
15763 {
15764 css_cnt_r = 2;
15765 }
15766 else
15767 {
15768 css_cnt_r = 4;
15769 }
15770 }
15771 else
15772 {
15773 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15774 {
15775 css_cnt_r = 3;
15776 }
15777 else
15778 {
15779 css_cnt_r = 4;
15780 }
15781 }
15782 }
15783 }
15784 else
15785 {
15786 css_cnt_r = 1;
15787
15788 /* unfinished code?
15789 int sum = css_buf[css_cnt_r - 1].cs_len;
15790
15791 for (uint i = 1; i < 4 && i < css_cnt; i++)
15792 {
15793 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15794
15795 css_cnt_r++;
15796
15797 sum *= css_buf[css_cnt_r - 1].cs_len;
15798 }
15799 */
15800 }
15801
15802 css_cnt_l -= css_cnt_r;
15803
15804 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15805
15806 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15807 {
15808 hc_device_param_t *device_param = &data.devices_param[device_id];
15809
15810 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15811 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15812 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15813
15814 device_param->kernel_params_mp_l_buf64[3] = 0;
15815 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15816 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15817 device_param->kernel_params_mp_l_buf32[6] = 0;
15818 device_param->kernel_params_mp_l_buf32[7] = 0;
15819 device_param->kernel_params_mp_l_buf32[8] = 0;
15820
15821 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15822 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15823 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15824 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15825
15826 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15827 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15828 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15829
15830 device_param->kernel_params_mp_r_buf64[3] = 0;
15831 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15832 device_param->kernel_params_mp_r_buf32[5] = 0;
15833 device_param->kernel_params_mp_r_buf32[6] = 0;
15834 device_param->kernel_params_mp_r_buf32[7] = 0;
15835
15836 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]);
15837 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]);
15838 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]);
15839
15840 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]);
15841 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]);
15842 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]);
15843
15844 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);
15845 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);
15846 }
15847 }
15848
15849 uint64_t words_base = data.words_cnt;
15850
15851 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15852 {
15853 if (data.kernel_rules_cnt)
15854 {
15855 words_base /= data.kernel_rules_cnt;
15856 }
15857 }
15858 else if (data.attack_kern == ATTACK_KERN_COMBI)
15859 {
15860 if (data.combs_cnt)
15861 {
15862 words_base /= data.combs_cnt;
15863 }
15864 }
15865 else if (data.attack_kern == ATTACK_KERN_BF)
15866 {
15867 if (data.bfs_cnt)
15868 {
15869 words_base /= data.bfs_cnt;
15870 }
15871 }
15872
15873 data.words_base = words_base;
15874
15875 if (keyspace == 1)
15876 {
15877 log_info ("%llu", (unsigned long long int) words_base);
15878
15879 return (0);
15880 }
15881
15882 if (data.words_cur > data.words_base)
15883 {
15884 log_error ("ERROR: restore value greater keyspace");
15885
15886 return (-1);
15887 }
15888
15889 if (data.words_cur)
15890 {
15891 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15892 {
15893 for (uint i = 0; i < data.salts_cnt; i++)
15894 {
15895 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
15896 }
15897 }
15898 else if (data.attack_kern == ATTACK_KERN_COMBI)
15899 {
15900 for (uint i = 0; i < data.salts_cnt; i++)
15901 {
15902 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
15903 }
15904 }
15905 else if (data.attack_kern == ATTACK_KERN_BF)
15906 {
15907 for (uint i = 0; i < data.salts_cnt; i++)
15908 {
15909 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
15910 }
15911 }
15912 }
15913
15914 /*
15915 * Inform user about possible slow speeds
15916 */
15917
15918 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15919 {
15920 if (data.words_base < kernel_blocks_all)
15921 {
15922 if (quiet == 0)
15923 {
15924 log_info ("");
15925 log_info ("ATTENTION!");
15926 log_info (" The wordlist or mask you are using is too small.");
15927 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
15928 log_info (" The cracking speed will drop.");
15929 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
15930 log_info ("");
15931 }
15932 }
15933 }
15934
15935 /*
15936 * Update loopback file
15937 */
15938
15939 if (loopback == 1)
15940 {
15941 time_t now;
15942
15943 time (&now);
15944
15945 uint random_num = get_random_num (0, 9999);
15946
15947 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
15948
15949 data.loopback_file = loopback_file;
15950 }
15951
15952 /*
15953 * Update dictionary statistic
15954 */
15955
15956 if (keyspace == 0)
15957 {
15958 dictstat_fp = fopen (dictstat, "wb");
15959
15960 if (dictstat_fp)
15961 {
15962 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
15963
15964 fclose (dictstat_fp);
15965 }
15966 }
15967
15968 data.devices_status = STATUS_RUNNING;
15969
15970 if (initial_restore_done == 0)
15971 {
15972 if (data.restore_disable == 0) cycle_restore ();
15973
15974 initial_restore_done = 1;
15975 }
15976
15977 hc_timer_set (&data.timer_running);
15978
15979 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15980 {
15981 if ((quiet == 0) && (status == 0) && (benchmark == 0))
15982 {
15983 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
15984 if (quiet == 0) fflush (stdout);
15985 }
15986 }
15987 else if (wordlist_mode == WL_MODE_STDIN)
15988 {
15989 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
15990 if (data.quiet == 0) log_info ("");
15991 }
15992
15993 time_t runtime_start;
15994
15995 time (&runtime_start);
15996
15997 data.runtime_start = runtime_start;
15998
15999 /**
16000 * create cracker threads
16001 */
16002
16003 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16004
16005 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16006 {
16007 hc_device_param_t *device_param = &devices_param[device_id];
16008
16009 device_param->device_id = device_id;
16010
16011 if (wordlist_mode == WL_MODE_STDIN)
16012 {
16013 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16014 }
16015 else
16016 {
16017 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16018 }
16019 }
16020
16021 // wait for crack threads to exit
16022
16023 hc_thread_wait (devices_cnt, c_threads);
16024
16025 local_free (c_threads);
16026
16027 data.restore = 0;
16028
16029 // finalize task
16030
16031 logfile_sub_var_uint ("status-after-work", data.devices_status);
16032
16033 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16034
16035 if (data.devices_status == STATUS_CRACKED) break;
16036 if (data.devices_status == STATUS_ABORTED) break;
16037
16038 if (data.devices_status == STATUS_BYPASS)
16039 {
16040 data.devices_status = STATUS_RUNNING;
16041 }
16042
16043 if (induction_dictionaries_cnt)
16044 {
16045 unlink (induction_dictionaries[0]);
16046 }
16047
16048 free (induction_dictionaries);
16049
16050 if (attack_mode != ATTACK_MODE_BF)
16051 {
16052 induction_dictionaries = scan_directory (induction_directory);
16053
16054 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16055 }
16056
16057 if (benchmark == 0)
16058 {
16059 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16060 {
16061 if (quiet == 0) clear_prompt ();
16062
16063 if (quiet == 0) log_info ("");
16064
16065 if (status == 1)
16066 {
16067 status_display ();
16068 }
16069 else
16070 {
16071 if (quiet == 0) status_display ();
16072 }
16073
16074 if (quiet == 0) log_info ("");
16075 }
16076 }
16077
16078 if (attack_mode == ATTACK_MODE_BF)
16079 {
16080 dictpos++;
16081
16082 rd->dictpos = dictpos;
16083 }
16084 else
16085 {
16086 if (induction_dictionaries_cnt)
16087 {
16088 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16089 }
16090 else
16091 {
16092 dictpos++;
16093
16094 rd->dictpos = dictpos;
16095 }
16096 }
16097
16098 time_t runtime_stop;
16099
16100 time (&runtime_stop);
16101
16102 data.runtime_stop = runtime_stop;
16103
16104 logfile_sub_uint (runtime_start);
16105 logfile_sub_uint (runtime_stop);
16106
16107 logfile_sub_msg ("STOP");
16108
16109 global_free (subid);
16110 }
16111
16112 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16113
16114 if (data.devices_status == STATUS_CRACKED) break;
16115 if (data.devices_status == STATUS_ABORTED) break;
16116 if (data.devices_status == STATUS_QUIT) break;
16117
16118 if (data.devices_status == STATUS_BYPASS)
16119 {
16120 data.devices_status = STATUS_RUNNING;
16121 }
16122 }
16123
16124 // 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
16125
16126 if (attack_mode == ATTACK_MODE_STRAIGHT)
16127 {
16128 if (data.wordlist_mode == WL_MODE_FILE)
16129 {
16130 if (data.dictfile == NULL)
16131 {
16132 if (dictfiles != NULL)
16133 {
16134 data.dictfile = dictfiles[0];
16135
16136 hc_timer_set (&data.timer_running);
16137 }
16138 }
16139 }
16140 }
16141 // NOTE: combi is okay because it is already set beforehand
16142 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16143 {
16144 if (data.dictfile == NULL)
16145 {
16146 if (dictfiles != NULL)
16147 {
16148 hc_timer_set (&data.timer_running);
16149
16150 data.dictfile = dictfiles[0];
16151 }
16152 }
16153 }
16154 else if (attack_mode == ATTACK_MODE_BF)
16155 {
16156 if (data.mask == NULL)
16157 {
16158 hc_timer_set (&data.timer_running);
16159
16160 data.mask = masks[0];
16161 }
16162 }
16163
16164 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16165 {
16166 data.devices_status = STATUS_EXHAUSTED;
16167 }
16168
16169 // if cracked / aborted remove last induction dictionary
16170
16171 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16172 {
16173 struct stat induct_stat;
16174
16175 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16176 {
16177 unlink (induction_dictionaries[file_pos]);
16178 }
16179 }
16180
16181 // wait for non-interactive threads
16182
16183 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16184 {
16185 hc_thread_wait (1, &ni_threads[thread_idx]);
16186 }
16187
16188 local_free (ni_threads);
16189
16190 // wait for interactive threads
16191
16192 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16193 {
16194 hc_thread_wait (1, &i_thread);
16195 }
16196
16197 // we dont need restore file anymore
16198 if (data.restore_disable == 0)
16199 {
16200 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16201 {
16202 unlink (eff_restore_file);
16203 unlink (new_restore_file);
16204 }
16205 else
16206 {
16207 cycle_restore ();
16208 }
16209 }
16210
16211 // finally save left hashes
16212
16213 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16214 {
16215 save_hash ();
16216 }
16217
16218 /**
16219 * Clean up
16220 */
16221
16222 if (benchmark == 1)
16223 {
16224 status_benchmark ();
16225
16226 log_info ("");
16227 }
16228 else
16229 {
16230 if (quiet == 0) clear_prompt ();
16231
16232 if (quiet == 0) log_info ("");
16233
16234 if (status == 1)
16235 {
16236 status_display ();
16237 }
16238 else
16239 {
16240 if (quiet == 0) status_display ();
16241 }
16242
16243 if (quiet == 0) log_info ("");
16244 }
16245
16246 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16247 {
16248 hc_device_param_t *device_param = &data.devices_param[device_id];
16249
16250 local_free (device_param->result);
16251
16252 local_free (device_param->pw_caches);
16253
16254 local_free (device_param->combs_buf);
16255
16256 local_free (device_param->hooks_buf);
16257
16258 local_free (device_param->device_name);
16259
16260 local_free (device_param->device_name_chksum);
16261
16262 local_free (device_param->device_version);
16263
16264 local_free (device_param->driver_version);
16265
16266 if (device_param->pws_buf) myfree (device_param->pws_buf);
16267 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16268 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16269 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16270 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16271 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16272 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16273 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16274 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16275 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16276 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16277 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16278 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16279 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16280 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16281 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16282 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16283 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16284 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16285 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16286 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16287 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16288 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16289 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16290 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16291 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16292 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16293 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16294 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16295
16296 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16297 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16298 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16299 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16300 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16301 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16302 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16303 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16304 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16305 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16306 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16307
16308 if (device_param->program) hc_clReleaseProgram (device_param->program);
16309 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16310 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16311
16312 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16313 if (device_param->context) hc_clReleaseContext (device_param->context);
16314 }
16315
16316 // reset default fan speed
16317
16318 if (gpu_temp_disable == 0)
16319 {
16320 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16321 {
16322 hc_thread_mutex_lock (mux_adl);
16323
16324 for (uint i = 0; i < data.devices_cnt; i++)
16325 {
16326 if (data.hm_device[i].fan_supported == 1)
16327 {
16328 int fanspeed = temp_retain_fanspeed_value[i];
16329
16330 if (fanspeed == -1) continue;
16331
16332 int rc = hm_set_fanspeed_with_device_id_amd (i, fanspeed);
16333
16334 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
16335 }
16336 }
16337
16338 hc_thread_mutex_unlock (mux_adl);
16339 }
16340 }
16341
16342 // reset power tuning
16343
16344 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16345 {
16346 hc_thread_mutex_lock (mux_adl);
16347
16348 for (uint i = 0; i < data.devices_cnt; i++)
16349 {
16350 if (data.hm_device[i].od_version == 6)
16351 {
16352 // check powertune capabilities first, if not available then skip device
16353
16354 int powertune_supported = 0;
16355
16356 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
16357 {
16358 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16359
16360 return (-1);
16361 }
16362
16363 if (powertune_supported != 0)
16364 {
16365 // powercontrol settings
16366
16367 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[i].adapter_index.amd, od_power_control_status[i])) != ADL_OK)
16368 {
16369 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16370
16371 return (-1);
16372 }
16373
16374 // clocks
16375
16376 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16377
16378 performance_state->iNumberOfPerformanceLevels = 2;
16379
16380 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
16381 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
16382 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
16383 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
16384
16385 if ((hc_ADL_Overdrive_State_Set (data.hm_dll_amd, data.hm_device[i].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16386 {
16387 log_info ("ERROR: Failed to restore ADL performance state");
16388
16389 return (-1);
16390 }
16391
16392 local_free (performance_state);
16393 }
16394 }
16395 }
16396
16397 hc_thread_mutex_unlock (mux_adl);
16398 }
16399
16400 if (gpu_temp_disable == 0)
16401 {
16402 #ifdef LINUX
16403 if (data.hm_dll_nv)
16404 {
16405 hc_NVML_nvmlShutdown (data.hm_dll_nv);
16406
16407 hm_close (data.hm_dll_nv);
16408 }
16409 #endif
16410
16411 #ifdef WIN
16412 NvAPI_Unload ();
16413 #endif
16414
16415 if (data.hm_dll_amd)
16416 {
16417 hc_ADL_Main_Control_Destroy (data.hm_dll_amd);
16418
16419 hm_close (data.hm_dll_amd);
16420 }
16421 }
16422
16423 // free memory
16424
16425 local_free (masks);
16426
16427 local_free (dictstat_base);
16428
16429 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16430 {
16431 pot_t *pot_ptr = &pot[pot_pos];
16432
16433 hash_t *hash = &pot_ptr->hash;
16434
16435 local_free (hash->digest);
16436
16437 if (isSalted)
16438 {
16439 local_free (hash->salt);
16440 }
16441 }
16442
16443 local_free (pot);
16444
16445 local_free (all_kernel_rules_cnt);
16446 local_free (all_kernel_rules_buf);
16447
16448 local_free (wl_data->buf);
16449 local_free (wl_data);
16450
16451 local_free (bitmap_s1_a);
16452 local_free (bitmap_s1_b);
16453 local_free (bitmap_s1_c);
16454 local_free (bitmap_s1_d);
16455 local_free (bitmap_s2_a);
16456 local_free (bitmap_s2_b);
16457 local_free (bitmap_s2_c);
16458 local_free (bitmap_s2_d);
16459
16460 local_free (temp_retain_fanspeed_value);
16461 local_free (od_clock_mem_status);
16462 local_free (od_power_control_status);
16463
16464 global_free (devices_param);
16465
16466 global_free (kernel_rules_buf);
16467
16468 global_free (root_css_buf);
16469 global_free (markov_css_buf);
16470
16471 global_free (digests_buf);
16472 global_free (digests_shown);
16473 global_free (digests_shown_tmp);
16474
16475 global_free (salts_buf);
16476 global_free (salts_shown);
16477
16478 global_free (esalts_buf);
16479
16480 global_free (words_progress_done);
16481 global_free (words_progress_rejected);
16482 global_free (words_progress_restored);
16483
16484 if (pot_fp) fclose (pot_fp);
16485
16486 if (data.devices_status == STATUS_QUIT) break;
16487 }
16488
16489 // destroy others mutex
16490
16491 hc_thread_mutex_delete (mux_dispatcher);
16492 hc_thread_mutex_delete (mux_counter);
16493 hc_thread_mutex_delete (mux_display);
16494 hc_thread_mutex_delete (mux_adl);
16495
16496 // free memory
16497
16498 local_free (eff_restore_file);
16499 local_free (new_restore_file);
16500
16501 local_free (rd);
16502
16503 // loopback
16504
16505 local_free (loopback_file);
16506
16507 if (loopback == 1) unlink (loopback_file);
16508
16509 // induction directory
16510
16511 if (induction_dir == NULL)
16512 {
16513 if (attack_mode != ATTACK_MODE_BF)
16514 {
16515 if (rmdir (induction_directory) == -1)
16516 {
16517 if (errno == ENOENT)
16518 {
16519 // good, we can ignore
16520 }
16521 else if (errno == ENOTEMPTY)
16522 {
16523 // good, we can ignore
16524 }
16525 else
16526 {
16527 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16528
16529 return (-1);
16530 }
16531 }
16532
16533 local_free (induction_directory);
16534 }
16535 }
16536
16537 // outfile-check directory
16538
16539 if (outfile_check_dir == NULL)
16540 {
16541 if (rmdir (outfile_check_directory) == -1)
16542 {
16543 if (errno == ENOENT)
16544 {
16545 // good, we can ignore
16546 }
16547 else if (errno == ENOTEMPTY)
16548 {
16549 // good, we can ignore
16550 }
16551 else
16552 {
16553 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16554
16555 return (-1);
16556 }
16557 }
16558
16559 local_free (outfile_check_directory);
16560 }
16561
16562 time_t proc_stop;
16563
16564 time (&proc_stop);
16565
16566 logfile_top_uint (proc_start);
16567 logfile_top_uint (proc_stop);
16568
16569 logfile_top_msg ("STOP");
16570
16571 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16572 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16573
16574 if (data.devices_status == STATUS_ABORTED) return 2;
16575 if (data.devices_status == STATUS_QUIT) return 2;
16576 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16577 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16578 if (data.devices_status == STATUS_CRACKED) return 0;
16579
16580 return -1;
16581 }
Hashcat additions to support pwdhash