projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Prepare new SIMD code for kernel, -m 0, 10, 20, 1000 should work in -a 3 mode and...
[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 #define OPENCL_VECTOR_WIDTH 0
84
85 #define WL_MODE_STDIN 1
86 #define WL_MODE_FILE 2
87 #define WL_MODE_MASK 3
88
89 #define HL_MODE_FILE 4
90 #define HL_MODE_ARG 5
91
92 #define HLFMT_HASHCAT 0
93 #define HLFMT_PWDUMP 1
94 #define HLFMT_PASSWD 2
95 #define HLFMT_SHADOW 3
96 #define HLFMT_DCC 4
97 #define HLFMT_DCC2 5
98 #define HLFMT_NETNTLM1 7
99 #define HLFMT_NETNTLM2 8
100 #define HLFMT_NSLDAP 9
101 #define HLFMT_NSLDAPS 10
102 #define HLFMTS_CNT 11
103
104 #define ATTACK_MODE_STRAIGHT 0
105 #define ATTACK_MODE_COMBI 1
106 #define ATTACK_MODE_TOGGLE 2
107 #define ATTACK_MODE_BF 3
108 #define ATTACK_MODE_PERM 4
109 #define ATTACK_MODE_TABLE 5
110 #define ATTACK_MODE_HYBRID1 6
111 #define ATTACK_MODE_HYBRID2 7
112 #define ATTACK_MODE_NONE 100
113
114 #define ATTACK_KERN_STRAIGHT 0
115 #define ATTACK_KERN_COMBI 1
116 #define ATTACK_KERN_BF 3
117 #define ATTACK_KERN_NONE 100
118
119 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
120 #define ATTACK_EXEC_INSIDE_KERNEL 11
121
122 #define COMBINATOR_MODE_BASE_LEFT 10001
123 #define COMBINATOR_MODE_BASE_RIGHT 10002
124
125 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
126 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
127
128 #define MAX_CUT_TRIES 4
129
130 #define MAX_DICTSTAT 10000
131
132 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
133
134 #define global_free(attr) \
135 { \
136 myfree ((void *) data.attr); \
137 \
138 data.attr = NULL; \
139 }
140
141 #define local_free(attr) \
142 { \
143 myfree ((void *) attr); \
144 \
145 attr = NULL; \
146 }
147
148 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
149 {
150 900,
151 0,
152 5100,
153 100,
154 1400,
155 10800,
156 1700,
157 5000,
158 10100,
159 6000,
160 6100,
161 6900,
162 11700,
163 11800,
164 400,
165 8900,
166 11900,
167 12000,
168 10900,
169 12100,
170 23,
171 2500,
172 5300,
173 5400,
174 5500,
175 5600,
176 7300,
177 7500,
178 8300,
179 11100,
180 11200,
181 11400,
182 121,
183 2611,
184 2711,
185 2811,
186 8400,
187 11,
188 2612,
189 7900,
190 21,
191 11000,
192 124,
193 10000,
194 3711,
195 7600,
196 12,
197 131,
198 132,
199 1731,
200 200,
201 300,
202 3100,
203 112,
204 12300,
205 8000,
206 141,
207 1441,
208 1600,
209 12600,
210 1421,
211 101,
212 111,
213 1711,
214 3000,
215 1000,
216 1100,
217 2100,
218 12800,
219 1500,
220 12400,
221 500,
222 3200,
223 7400,
224 1800,
225 122,
226 1722,
227 7100,
228 6300,
229 6700,
230 6400,
231 6500,
232 2400,
233 2410,
234 5700,
235 9200,
236 9300,
237 22,
238 501,
239 5800,
240 8100,
241 8500,
242 7200,
243 9900,
244 7700,
245 7800,
246 10300,
247 8600,
248 8700,
249 9100,
250 133,
251 11600,
252 12500,
253 13000,
254 6211,
255 6221,
256 6231,
257 6241,
258 8800,
259 12900,
260 12200,
261 9700,
262 9710,
263 9800,
264 9810,
265 9400,
266 9500,
267 9600,
268 10400,
269 10410,
270 10500,
271 10600,
272 10700,
273 9000,
274 5200,
275 6800,
276 6600,
277 8200,
278 11300,
279 12700
280 };
281
282 /**
283 * types
284 */
285
286 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
287
288 /**
289 * globals
290 */
291
292 static unsigned int full01 = 0x01010101;
293 static unsigned int full80 = 0x80808080;
294
295 int SUPPRESS_OUTPUT = 0;
296
297 hc_thread_mutex_t mux_adl;
298 hc_thread_mutex_t mux_counter;
299 hc_thread_mutex_t mux_dispatcher;
300 hc_thread_mutex_t mux_display;
301
302 hc_global_data_t data;
303
304 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
305
306 const char *USAGE_MINI[] =
307 {
308 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
309 "",
310 "Try --help for more help.",
311 NULL
312 };
313
314 const char *USAGE_BIG[] =
315 {
316 "%s, advanced password recovery",
317 "",
318 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
319 "",
320 "=======",
321 "Options",
322 "=======",
323 "",
324 "* General:",
325 "",
326 " -m, --hash-type=NUM Hash-type, see references below",
327 " -a, --attack-mode=NUM Attack-mode, see references below",
328 " -V, --version Print version",
329 " -h, --help Print help",
330 " --quiet Suppress output",
331 "",
332 "* Benchmark:",
333 "",
334 " -b, --benchmark Run benchmark",
335 " --benchmark-mode=NUM Benchmark-mode, see references below",
336 "",
337 "* Misc:",
338 "",
339 " --hex-charset Assume charset is given in hex",
340 " --hex-salt Assume salt is given in hex",
341 " --hex-wordlist Assume words in wordlist is given in hex",
342 " --force Ignore warnings",
343 " --status Enable automatic update of the status-screen",
344 " --status-timer=NUM Seconds between status-screen update",
345 " --status-automat Display the status view in a machine readable format",
346 " --loopback Add new plains to induct directory",
347 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
348 "",
349 "* Markov:",
350 "",
351 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
352 " --markov-disable Disables markov-chains, emulates classic brute-force",
353 " --markov-classic Enables classic markov-chains, no per-position enhancement",
354 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
355 "",
356 "* Session:",
357 "",
358 " --runtime=NUM Abort session after NUM seconds of runtime",
359 " --session=STR Define specific session name",
360 " --restore Restore session from --session",
361 " --restore-disable Do not write restore file",
362 "",
363 "* Files:",
364 "",
365 " -o, --outfile=FILE Define outfile for recovered hash",
366 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
367 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
368 " --outfile-check-timer=NUM Seconds between outfile checks",
369 " -p, --separator=CHAR Separator char for hashlists and outfile",
370 " --show Show cracked passwords only",
371 " --left Show un-cracked passwords only",
372 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
373 " --remove Enable remove of hash once it is cracked",
374 " --remove-timer=NUM Update input hash file each NUM seconds",
375 " --potfile-disable Do not write potfile",
376 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
377 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
378 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
379 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
380 " --logfile-disable Disable the logfile",
381 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
382 "",
383 "* Resources:",
384 "",
385 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
386 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
387 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
388 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
389 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
390 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
391 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
392 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
393 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
394 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
395 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
396 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
397 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
398 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
399 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
400 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
401 "",
402 "* Distributed:",
403 "",
404 " -s, --skip=NUM Skip number of words",
405 " -l, --limit=NUM Limit number of words",
406 " --keyspace Show keyspace base:mod values and quit",
407 "",
408 "* Rules:",
409 "",
410 " -j, --rule-left=RULE Single rule applied to each word from left dict",
411 " -k, --rule-right=RULE Single rule applied to each word from right dict",
412 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
413 " -g, --generate-rules=NUM Generate NUM random rules",
414 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
415 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
416 " --generate-rules-seed=NUM Force RNG seed to NUM",
417 "",
418 "* Custom charsets:",
419 "",
420 " -1, --custom-charset1=CS User-defined charsets",
421 " -2, --custom-charset2=CS Example:",
422 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
423 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
424 "",
425 "* Increment:",
426 "",
427 " -i, --increment Enable increment mode",
428 " --increment-min=NUM Start incrementing at NUM",
429 " --increment-max=NUM Stop incrementing at NUM",
430 "",
431 "==========",
432 "References",
433 "==========",
434 "",
435 "* Workload Profile:",
436 "",
437 " 1 = Reduced performance profile (low latency desktop)",
438 " 2 = Default performance profile",
439 " 3 = Tuned performance profile (high latency desktop)",
440 "",
441 "* Benchmark Settings:",
442 "",
443 " 0 = Manual Tuning",
444 " 1 = Performance Tuning, default",
445 "",
446 "* OpenCL device-types:",
447 "",
448 " 1 = CPU devices",
449 " 2 = GPU devices",
450 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
451 "",
452 "* Outfile Formats:",
453 "",
454 " 1 = hash[:salt]",
455 " 2 = plain",
456 " 3 = hash[:salt]:plain",
457 " 4 = hex_plain",
458 " 5 = hash[:salt]:hex_plain",
459 " 6 = plain:hex_plain",
460 " 7 = hash[:salt]:plain:hex_plain",
461 " 8 = crackpos",
462 " 9 = hash[:salt]:crackpos",
463 " 10 = plain:crackpos",
464 " 11 = hash[:salt]:plain:crackpos",
465 " 12 = hex_plain:crackpos",
466 " 13 = hash[:salt]:hex_plain:crackpos",
467 " 14 = plain:hex_plain:crackpos",
468 " 15 = hash[:salt]:plain:hex_plain:crackpos",
469 "",
470 "* Debug mode output formats (for hybrid mode only, by using rules):",
471 "",
472 " 1 = save finding rule",
473 " 2 = save original word",
474 " 3 = save original word and finding rule",
475 " 4 = save original word, finding rule and modified plain",
476 "",
477 "* Built-in charsets:",
478 "",
479 " ?l = abcdefghijklmnopqrstuvwxyz",
480 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
481 " ?d = 0123456789",
482 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
483 " ?a = ?l?u?d?s",
484 " ?b = 0x00 - 0xff",
485 "",
486 "* Attack modes:",
487 "",
488 " 0 = Straight",
489 " 1 = Combination",
490 " 3 = Brute-force",
491 " 6 = Hybrid dict + mask",
492 " 7 = Hybrid mask + dict",
493 "",
494 "* Hash types:",
495 "",
496 "[[ Roll-your-own: Raw Hashes ]]",
497 "",
498 " 900 = MD4",
499 " 0 = MD5",
500 " 5100 = Half MD5",
501 " 100 = SHA1",
502 " 10800 = SHA-384",
503 " 1400 = SHA-256",
504 " 1700 = SHA-512",
505 " 5000 = SHA-3(Keccak)",
506 " 10100 = SipHash",
507 " 6000 = RipeMD160",
508 " 6100 = Whirlpool",
509 " 6900 = GOST R 34.11-94",
510 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
511 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
512 "",
513 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
514 "",
515 " 10 = md5($pass.$salt)",
516 " 20 = md5($salt.$pass)",
517 " 30 = md5(unicode($pass).$salt)",
518 " 40 = md5($salt.unicode($pass))",
519 " 3800 = md5($salt.$pass.$salt)",
520 " 3710 = md5($salt.md5($pass))",
521 " 2600 = md5(md5($pass)",
522 " 4300 = md5(strtoupper(md5($pass)))",
523 " 4400 = md5(sha1($pass))",
524 " 110 = sha1($pass.$salt)",
525 " 120 = sha1($salt.$pass)",
526 " 130 = sha1(unicode($pass).$salt)",
527 " 140 = sha1($salt.unicode($pass))",
528 " 4500 = sha1(sha1($pass)",
529 " 4700 = sha1(md5($pass))",
530 " 4900 = sha1($salt.$pass.$salt)",
531 " 1410 = sha256($pass.$salt)",
532 " 1420 = sha256($salt.$pass)",
533 " 1430 = sha256(unicode($pass).$salt)",
534 " 1440 = sha256($salt.unicode($pass))",
535 " 1710 = sha512($pass.$salt)",
536 " 1720 = sha512($salt.$pass)",
537 " 1730 = sha512(unicode($pass).$salt)",
538 " 1740 = sha512($salt.unicode($pass))",
539 "",
540 "[[ Roll-your-own: Authenticated Hashes ]]",
541 "",
542 " 50 = HMAC-MD5 (key = $pass)",
543 " 60 = HMAC-MD5 (key = $salt)",
544 " 150 = HMAC-SHA1 (key = $pass)",
545 " 160 = HMAC-SHA1 (key = $salt)",
546 " 1450 = HMAC-SHA256 (key = $pass)",
547 " 1460 = HMAC-SHA256 (key = $salt)",
548 " 1750 = HMAC-SHA512 (key = $pass)",
549 " 1760 = HMAC-SHA512 (key = $salt)",
550 "",
551 "[[ Generic KDF ]]",
552 "",
553 " 400 = phpass",
554 " 8900 = scrypt",
555 " 11900 = PBKDF2-HMAC-MD5",
556 " 12000 = PBKDF2-HMAC-SHA1",
557 " 10900 = PBKDF2-HMAC-SHA256",
558 " 12100 = PBKDF2-HMAC-SHA512",
559 "",
560 "[[ Network protocols, Challenge-Response ]]",
561 "",
562 " 23 = Skype",
563 " 2500 = WPA/WPA2",
564 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
565 " 5300 = IKE-PSK MD5",
566 " 5400 = IKE-PSK SHA1",
567 " 5500 = NetNTLMv1",
568 " 5500 = NetNTLMv1 + ESS",
569 " 5600 = NetNTLMv2",
570 " 7300 = IPMI2 RAKP HMAC-SHA1",
571 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
572 " 8300 = DNSSEC (NSEC3)",
573 " 10200 = Cram MD5",
574 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
575 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
576 " 11400 = SIP digest authentication (MD5)",
577 "",
578 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
579 "",
580 " 121 = SMF (Simple Machines Forum)",
581 " 400 = phpBB3",
582 " 2611 = vBulletin < v3.8.5",
583 " 2711 = vBulletin > v3.8.5",
584 " 2811 = MyBB",
585 " 2811 = IPB (Invison Power Board)",
586 " 8400 = WBB3 (Woltlab Burning Board)",
587 " 11 = Joomla < 2.5.18",
588 " 400 = Joomla > 2.5.18",
589 " 400 = Wordpress",
590 " 2612 = PHPS",
591 " 7900 = Drupal7",
592 " 21 = osCommerce",
593 " 21 = xt:Commerce",
594 " 11000 = PrestaShop",
595 " 124 = Django (SHA-1)",
596 " 10000 = Django (PBKDF2-SHA256)",
597 " 3711 = Mediawiki B type",
598 " 7600 = Redmine",
599 "",
600 "[[ Database Server ]]",
601 "",
602 " 12 = PostgreSQL",
603 " 131 = MSSQL(2000)",
604 " 132 = MSSQL(2005)",
605 " 1731 = MSSQL(2012)",
606 " 1731 = MSSQL(2014)",
607 " 200 = MySQL323",
608 " 300 = MySQL4.1/MySQL5",
609 " 3100 = Oracle H: Type (Oracle 7+)",
610 " 112 = Oracle S: Type (Oracle 11+)",
611 " 12300 = Oracle T: Type (Oracle 12+)",
612 " 8000 = Sybase ASE",
613 "",
614 "[[ HTTP, SMTP, LDAP Server ]]",
615 "",
616 " 141 = EPiServer 6.x < v4",
617 " 1441 = EPiServer 6.x > v4",
618 " 1600 = Apache $apr1$",
619 " 12600 = ColdFusion 10+",
620 " 1421 = hMailServer",
621 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
622 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
623 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
624 "",
625 "[[ Checksums ]]",
626 "",
627 " 11500 = CRC32",
628 "",
629 "[[ Operating-Systems ]]",
630 "",
631 " 3000 = LM",
632 " 1000 = NTLM",
633 " 1100 = Domain Cached Credentials (DCC), MS Cache",
634 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
635 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
636 " 1500 = descrypt, DES(Unix), Traditional DES",
637 " 12400 = BSDiCrypt, Extended DES",
638 " 500 = md5crypt $1$, MD5(Unix)",
639 " 3200 = bcrypt $2*$, Blowfish(Unix)",
640 " 7400 = sha256crypt $5$, SHA256(Unix)",
641 " 1800 = sha512crypt $6$, SHA512(Unix)",
642 " 122 = OSX v10.4",
643 " 122 = OSX v10.5",
644 " 122 = OSX v10.6",
645 " 1722 = OSX v10.7",
646 " 7100 = OSX v10.8",
647 " 7100 = OSX v10.9",
648 " 7100 = OSX v10.10",
649 " 6300 = AIX {smd5}",
650 " 6700 = AIX {ssha1}",
651 " 6400 = AIX {ssha256}",
652 " 6500 = AIX {ssha512}",
653 " 2400 = Cisco-PIX",
654 " 2410 = Cisco-ASA",
655 " 500 = Cisco-IOS $1$",
656 " 5700 = Cisco-IOS $4$",
657 " 9200 = Cisco-IOS $8$",
658 " 9300 = Cisco-IOS $9$",
659 " 22 = Juniper Netscreen/SSG (ScreenOS)",
660 " 501 = Juniper IVE",
661 " 5800 = Android PIN",
662 " 8100 = Citrix Netscaler",
663 " 8500 = RACF",
664 " 7200 = GRUB 2",
665 " 9900 = Radmin2",
666 "",
667 "[[ Enterprise Application Software (EAS) ]]",
668 "",
669 " 7700 = SAP CODVN B (BCODE)",
670 " 7800 = SAP CODVN F/G (PASSCODE)",
671 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
672 " 8600 = Lotus Notes/Domino 5",
673 " 8700 = Lotus Notes/Domino 6",
674 " 9100 = Lotus Notes/Domino 8",
675 " 133 = PeopleSoft",
676 "",
677 "[[ Archives ]]",
678 "",
679 " 11600 = 7-Zip",
680 " 12500 = RAR3-hp",
681 " 13000 = RAR5",
682 "",
683 "[[ Full-Disk encryptions (FDE) ]]",
684 "",
685 " 62XY = TrueCrypt 5.0+",
686 " X = 1 = PBKDF2-HMAC-RipeMD160",
687 " X = 2 = PBKDF2-HMAC-SHA512",
688 " X = 3 = PBKDF2-HMAC-Whirlpool",
689 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
690 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
691 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
692 " Y = 3 = XTS 1536 bit (Ciphers: All)",
693 " 8800 = Android FDE < v4.3",
694 " 12900 = Android FDE (Samsung DEK)",
695 " 12200 = eCryptfs",
696 "",
697 "[[ Documents ]]",
698 "",
699 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
700 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
701 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
702 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
703 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
704 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
705 " 9400 = MS Office 2007",
706 " 9500 = MS Office 2010",
707 " 9600 = MS Office 2013",
708 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
709 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
710 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
711 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
712 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
713 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
714 "",
715 "[[ Password Managers ]]",
716 "",
717 " 9000 = Password Safe v2",
718 " 5200 = Password Safe v3",
719 " 6800 = Lastpass",
720 " 6600 = 1Password, agilekeychain",
721 " 8200 = 1Password, cloudkeychain",
722 " 11300 = Bitcoin/Litecoin wallet.dat",
723 " 12700 = Blockchain, My Wallet",
724 "",
725 NULL
726 };
727
728 /**
729 * oclHashcat specific functions
730 */
731
732 void status_display_automat ()
733 {
734 FILE *out = stdout;
735
736 fprintf (out, "STATUS\t%u\t", data.devices_status);
737
738 /**
739 * speed new
740 */
741
742 fprintf (out, "SPEED\t");
743
744 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
745 {
746 hc_device_param_t *device_param = &data.devices_param[device_id];
747
748 if (device_param->skipped) continue;
749
750 u64 speed_cnt = 0;
751 float speed_ms = 0;
752
753 for (int i = 0; i < SPEED_CACHE; i++)
754 {
755 float rec_ms;
756
757 hc_timer_get (device_param->speed_rec[i], rec_ms);
758
759 if (rec_ms > SPEED_MAXAGE) continue;
760
761 speed_cnt += device_param->speed_cnt[i];
762 speed_ms += device_param->speed_ms[i];
763 }
764
765 speed_cnt /= SPEED_CACHE;
766 speed_ms /= SPEED_CACHE;
767
768 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
769 }
770
771 /**
772 * words_cur
773 */
774
775 u64 words_cur = get_lowest_words_done ();
776
777 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
778
779 /**
780 * counter
781 */
782
783 uint salts_left = data.salts_cnt - data.salts_done;
784
785 if (salts_left == 0) salts_left = 1;
786
787 u64 progress_total = data.words_cnt * salts_left;
788
789 u64 all_done = 0;
790 u64 all_rejected = 0;
791 u64 all_restored = 0;
792
793 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
794 {
795 if (salts_left > 1)
796 {
797 // otherwise the final cracked status shows 0/XXX progress
798
799 if (data.salts_shown[salt_pos] == 1) continue;
800 }
801
802 all_done += data.words_progress_done[salt_pos];
803 all_rejected += data.words_progress_rejected[salt_pos];
804 all_restored += data.words_progress_restored[salt_pos];
805 }
806
807 u64 progress_cur = all_restored + all_done + all_rejected;
808 u64 progress_end = progress_total;
809
810 u64 progress_skip = 0;
811
812 if (data.skip)
813 {
814 progress_skip = MIN (data.skip, data.words_base) * salts_left;
815
816 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
817 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
818 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
819 }
820
821 if (data.limit)
822 {
823 progress_end = MIN (data.limit, data.words_base) * salts_left;
824
825 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
826 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
827 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
828 }
829
830 u64 progress_cur_relative_skip = progress_cur - progress_skip;
831 u64 progress_end_relative_skip = progress_end - progress_skip;
832
833 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
834
835 /**
836 * cracks
837 */
838
839 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
840 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
841
842 /**
843 * temperature
844 */
845
846 if (data.gpu_temp_disable == 0)
847 {
848 fprintf (out, "TEMP\t");
849
850 hc_thread_mutex_lock (mux_adl);
851
852 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
853 {
854 hc_device_param_t *device_param = &data.devices_param[device_id];
855
856 if (device_param->skipped) continue;
857
858 int temp = hm_get_temperature_with_device_id (device_id);
859
860 fprintf (out, "%d\t", temp);
861 }
862
863 hc_thread_mutex_unlock (mux_adl);
864 }
865
866 #ifdef _WIN
867 fputc ('\r', out);
868 fputc ('\n', out);
869 #endif
870
871 #ifdef _POSIX
872 fputc ('\n', out);
873 #endif
874
875 fflush (out);
876 }
877
878 void status_display ()
879 {
880 if (data.devices_status == STATUS_INIT) return;
881 if (data.devices_status == STATUS_STARTING) return;
882 if (data.devices_status == STATUS_BYPASS) return;
883
884 if (data.status_automat == 1)
885 {
886 status_display_automat ();
887
888 return;
889 }
890
891 char tmp_buf[1000];
892
893 uint tmp_len = 0;
894
895 log_info ("Session.Name...: %s", data.session);
896
897 char *status_type = strstatus (data.devices_status);
898
899 uint hash_mode = data.hash_mode;
900
901 char *hash_type = strhashtype (hash_mode); // not a bug
902
903 log_info ("Status.........: %s", status_type);
904
905 /**
906 * show rules
907 */
908
909 if (data.rp_files_cnt)
910 {
911 uint i;
912
913 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
914 {
915 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
916 }
917
918 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
919
920 log_info ("Rules.Type.....: %s", tmp_buf);
921
922 tmp_len = 0;
923 }
924
925 if (data.rp_gen)
926 {
927 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
928
929 if (data.rp_gen_seed)
930 {
931 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
932 }
933 }
934
935 /**
936 * show input
937 */
938
939 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
940 {
941 if (data.wordlist_mode == WL_MODE_FILE)
942 {
943 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
944 }
945 else if (data.wordlist_mode == WL_MODE_STDIN)
946 {
947 log_info ("Input.Mode.....: Pipe");
948 }
949 }
950 else if (data.attack_mode == ATTACK_MODE_COMBI)
951 {
952 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
953 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
954 }
955 else if (data.attack_mode == ATTACK_MODE_BF)
956 {
957 char *mask = data.mask;
958
959 if (mask != NULL)
960 {
961 uint mask_len = data.css_cnt;
962
963 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
964
965 if (mask_len > 0)
966 {
967 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
968 {
969 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
970 {
971 mask_len -= data.salts_buf[0].salt_len;
972 }
973 }
974
975 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
976
977 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
978 }
979
980 if (data.maskcnt > 1)
981 {
982 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
983
984 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
985 }
986
987 log_info ("Input.Mode.....: %s", tmp_buf);
988 }
989
990 tmp_len = 0;
991 }
992 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
993 {
994 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
995 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
996 }
997 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
998 {
999 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1000 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1001 }
1002
1003 if (data.digests_cnt == 1)
1004 {
1005 if (data.hash_mode == 2500)
1006 {
1007 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1008
1009 uint pke[25];
1010
1011 char *pke_ptr = (char *) pke;
1012
1013 for (uint i = 0; i < 25; i++)
1014 {
1015 pke[i] = byte_swap_32 (wpa->pke[i]);
1016 }
1017
1018 char mac1[6];
1019 char mac2[6];
1020
1021 memcpy (mac1, pke_ptr + 23, 6);
1022 memcpy (mac2, pke_ptr + 29, 6);
1023
1024 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1025 (char *) data.salts_buf[0].salt_buf,
1026 mac1[0] & 0xff,
1027 mac1[1] & 0xff,
1028 mac1[2] & 0xff,
1029 mac1[3] & 0xff,
1030 mac1[4] & 0xff,
1031 mac1[5] & 0xff,
1032 mac2[0] & 0xff,
1033 mac2[1] & 0xff,
1034 mac2[2] & 0xff,
1035 mac2[3] & 0xff,
1036 mac2[4] & 0xff,
1037 mac2[5] & 0xff);
1038 }
1039 else if (data.hash_mode == 5200)
1040 {
1041 log_info ("Hash.Target....: File (%s)", data.hashfile);
1042 }
1043 else if (data.hash_mode == 9000)
1044 {
1045 log_info ("Hash.Target....: File (%s)", data.hashfile);
1046 }
1047 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1048 {
1049 log_info ("Hash.Target....: File (%s)", data.hashfile);
1050 }
1051 else
1052 {
1053 char out_buf[4096];
1054
1055 ascii_digest (out_buf, 0, 0);
1056
1057 // limit length
1058 if (strlen (out_buf) > 40)
1059 {
1060 out_buf[41] = '.';
1061 out_buf[42] = '.';
1062 out_buf[43] = '.';
1063 out_buf[44] = 0;
1064 }
1065
1066 log_info ("Hash.Target....: %s", out_buf);
1067 }
1068 }
1069 else
1070 {
1071 if (data.hash_mode == 3000)
1072 {
1073 char out_buf1[4096];
1074 char out_buf2[4096];
1075
1076 ascii_digest (out_buf1, 0, 0);
1077 ascii_digest (out_buf2, 0, 1);
1078
1079 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1080 }
1081 else
1082 {
1083 log_info ("Hash.Target....: File (%s)", data.hashfile);
1084 }
1085 }
1086
1087 log_info ("Hash.Type......: %s", hash_type);
1088
1089 /**
1090 * speed new
1091 */
1092
1093 u64 speed_cnt[DEVICES_MAX];
1094 float speed_ms[DEVICES_MAX];
1095
1096 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1097 {
1098 hc_device_param_t *device_param = &data.devices_param[device_id];
1099
1100 if (device_param->skipped) continue;
1101
1102 // we need to clear values (set to 0) because in case the device does
1103 // not get new candidates it idles around but speed display would
1104 // show it as working.
1105 // if we instantly set it to 0 after reading it happens that the
1106 // speed can be shown as zero if the users refreshs to fast.
1107 // therefore, we add a timestamp when a stat was recorded and if its
1108 // to old we will not use it
1109
1110 speed_cnt[device_id] = 0;
1111 speed_ms[device_id] = 0;
1112
1113 for (int i = 0; i < SPEED_CACHE; i++)
1114 {
1115 float rec_ms;
1116
1117 hc_timer_get (device_param->speed_rec[i], rec_ms);
1118
1119 if (rec_ms > SPEED_MAXAGE) continue;
1120
1121 speed_cnt[device_id] += device_param->speed_cnt[i];
1122 speed_ms[device_id] += device_param->speed_ms[i];
1123 }
1124
1125 speed_cnt[device_id] /= SPEED_CACHE;
1126 speed_ms[device_id] /= SPEED_CACHE;
1127 }
1128
1129 float hashes_all_ms = 0;
1130
1131 float hashes_dev_ms[DEVICES_MAX];
1132
1133 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1134 {
1135 hc_device_param_t *device_param = &data.devices_param[device_id];
1136
1137 if (device_param->skipped) continue;
1138
1139 hashes_dev_ms[device_id] = 0;
1140
1141 if (speed_ms[device_id])
1142 {
1143 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1144
1145 hashes_all_ms += hashes_dev_ms[device_id];
1146 }
1147 }
1148
1149 /**
1150 * timers
1151 */
1152
1153 float ms_running = 0;
1154
1155 hc_timer_get (data.timer_running, ms_running);
1156
1157 float ms_paused = data.ms_paused;
1158
1159 if (data.devices_status == STATUS_PAUSED)
1160 {
1161 float ms_paused_tmp = 0;
1162
1163 hc_timer_get (data.timer_paused, ms_paused_tmp);
1164
1165 ms_paused += ms_paused_tmp;
1166 }
1167
1168 #ifdef WIN
1169
1170 __time64_t sec_run = ms_running / 1000;
1171
1172 #else
1173
1174 time_t sec_run = ms_running / 1000;
1175
1176 #endif
1177
1178 if (sec_run)
1179 {
1180 char display_run[32];
1181
1182 struct tm tm_run;
1183
1184 struct tm *tmp;
1185
1186 #ifdef WIN
1187
1188 tmp = _gmtime64 (&sec_run);
1189
1190 #else
1191
1192 tmp = gmtime (&sec_run);
1193
1194 #endif
1195
1196 if (tmp != NULL)
1197 {
1198 memcpy (&tm_run, tmp, sizeof (struct tm));
1199
1200 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1201
1202 char *start = ctime (&data.proc_start);
1203
1204 size_t start_len = strlen (start);
1205
1206 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1207 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1208
1209 log_info ("Time.Started...: %s (%s)", start, display_run);
1210 }
1211 }
1212 else
1213 {
1214 log_info ("Time.Started...: 0 secs");
1215 }
1216
1217 /**
1218 * counters
1219 */
1220
1221 uint salts_left = data.salts_cnt - data.salts_done;
1222
1223 if (salts_left == 0) salts_left = 1;
1224
1225 u64 progress_total = data.words_cnt * salts_left;
1226
1227 u64 all_done = 0;
1228 u64 all_rejected = 0;
1229 u64 all_restored = 0;
1230
1231 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1232 {
1233 if (salts_left > 1)
1234 {
1235 // otherwise the final cracked status shows 0/XXX progress
1236
1237 if (data.salts_shown[salt_pos] == 1) continue;
1238 }
1239
1240 all_done += data.words_progress_done[salt_pos];
1241 all_rejected += data.words_progress_rejected[salt_pos];
1242 all_restored += data.words_progress_restored[salt_pos];
1243 }
1244
1245 u64 progress_cur = all_restored + all_done + all_rejected;
1246 u64 progress_end = progress_total;
1247
1248 u64 progress_skip = 0;
1249
1250 if (data.skip)
1251 {
1252 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1253
1254 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1255 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1256 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1257 }
1258
1259 if (data.limit)
1260 {
1261 progress_end = MIN (data.limit, data.words_base) * salts_left;
1262
1263 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1264 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1265 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1266 }
1267
1268 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1269 u64 progress_end_relative_skip = progress_end - progress_skip;
1270
1271 float speed_ms_real = ms_running - ms_paused;
1272 u64 speed_plains_real = all_done;
1273
1274 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1275 {
1276 if (data.devices_status != STATUS_CRACKED)
1277 {
1278 u64 words_per_ms = 0;
1279
1280 if (speed_plains_real && speed_ms_real)
1281 {
1282 words_per_ms = speed_plains_real / speed_ms_real;
1283 }
1284
1285 #ifdef WIN
1286 __time64_t sec_etc = 0;
1287 #else
1288 time_t sec_etc = 0;
1289 #endif
1290
1291 if (words_per_ms)
1292 {
1293 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1294
1295 u64 ms_left = progress_left_relative_skip / words_per_ms;
1296
1297 sec_etc = ms_left / 1000;
1298 }
1299
1300 if (sec_etc == 0)
1301 {
1302 log_info ("Time.Estimated.: 0 secs");
1303 }
1304 else if ((u64) sec_etc > ETC_MAX)
1305 {
1306 log_info ("Time.Estimated.: > 10 Years");
1307 }
1308 else
1309 {
1310 char display_etc[32];
1311
1312 struct tm tm_etc;
1313
1314 struct tm *tmp;
1315
1316 #ifdef WIN
1317
1318 tmp = _gmtime64 (&sec_etc);
1319
1320 #else
1321
1322 tmp = gmtime (&sec_etc);
1323
1324 #endif
1325
1326 if (tmp != NULL)
1327 {
1328 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1329
1330 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1331
1332 time_t now;
1333
1334 time (&now);
1335
1336 now += sec_etc;
1337
1338 char *etc = ctime (&now);
1339
1340 size_t etc_len = strlen (etc);
1341
1342 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1343 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1344
1345 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1346 }
1347 }
1348 }
1349 }
1350
1351 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1352 {
1353 hc_device_param_t *device_param = &data.devices_param[device_id];
1354
1355 if (device_param->skipped) continue;
1356
1357 char display_dev_cur[16] = { 0 };
1358
1359 strncpy (display_dev_cur, "0.00", 4);
1360
1361 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1362
1363 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1364 }
1365
1366 char display_all_cur[16] = { 0 };
1367
1368 strncpy (display_all_cur, "0.00", 4);
1369
1370 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1371
1372 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1373
1374 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1375 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1376
1377 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);
1378
1379 // crack-per-time
1380
1381 if (data.digests_cnt > 100)
1382 {
1383 time_t now = time (NULL);
1384
1385 int cpt_cur_min = 0;
1386 int cpt_cur_hour = 0;
1387 int cpt_cur_day = 0;
1388
1389 for (int i = 0; i < CPT_BUF; i++)
1390 {
1391 const uint cracked = data.cpt_buf[i].cracked;
1392 const time_t timestamp = data.cpt_buf[i].timestamp;
1393
1394 if ((timestamp + 60) > now)
1395 {
1396 cpt_cur_min += cracked;
1397 }
1398
1399 if ((timestamp + 3600) > now)
1400 {
1401 cpt_cur_hour += cracked;
1402 }
1403
1404 if ((timestamp + 86400) > now)
1405 {
1406 cpt_cur_day += cracked;
1407 }
1408 }
1409
1410 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1411 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1412 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1413
1414 if ((data.cpt_start + 86400) < now)
1415 {
1416 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1417 cpt_cur_min,
1418 cpt_cur_hour,
1419 cpt_cur_day,
1420 cpt_avg_min,
1421 cpt_avg_hour,
1422 cpt_avg_day);
1423 }
1424 else if ((data.cpt_start + 3600) < now)
1425 {
1426 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1427 cpt_cur_min,
1428 cpt_cur_hour,
1429 cpt_avg_min,
1430 cpt_avg_hour,
1431 cpt_avg_day);
1432 }
1433 else if ((data.cpt_start + 60) < now)
1434 {
1435 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1436 cpt_cur_min,
1437 cpt_avg_min,
1438 cpt_avg_hour,
1439 cpt_avg_day);
1440 }
1441 else
1442 {
1443 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1444 cpt_avg_min,
1445 cpt_avg_hour,
1446 cpt_avg_day);
1447 }
1448 }
1449
1450 // Restore point
1451
1452 u64 restore_point = get_lowest_words_done ();
1453
1454 u64 restore_total = data.words_base;
1455
1456 float percent_restore = 0;
1457
1458 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1459
1460 if (progress_end_relative_skip)
1461 {
1462 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1463 {
1464 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1465 float percent_rejected = 0.0;
1466
1467 if (progress_cur)
1468 {
1469 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1470 }
1471
1472 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);
1473 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1474
1475 if (data.restore_disable == 0)
1476 {
1477 if (percent_finished != 1)
1478 {
1479 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1480 }
1481 }
1482 }
1483 }
1484 else
1485 {
1486 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1487 {
1488 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1489 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1490
1491 if (data.restore_disable == 0)
1492 {
1493 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1494 }
1495 }
1496 else
1497 {
1498 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1499 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1500
1501 // --restore not allowed if stdin is used -- really? why?
1502
1503 //if (data.restore_disable == 0)
1504 //{
1505 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1506 //}
1507 }
1508 }
1509
1510 if (data.gpu_temp_disable == 0)
1511 {
1512 hc_thread_mutex_lock (mux_adl);
1513
1514 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1515 {
1516 hc_device_param_t *device_param = &data.devices_param[device_id];
1517
1518 if (device_param->skipped) continue;
1519
1520 #define HM_STR_BUF_SIZE 255
1521
1522 if (data.hm_device[device_id].fan_supported == 1)
1523 {
1524 char utilization[HM_STR_BUF_SIZE];
1525 char temperature[HM_STR_BUF_SIZE];
1526 char fanspeed[HM_STR_BUF_SIZE];
1527
1528 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1529 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1530
1531 if (device_param->vendor_id == VENDOR_ID_AMD)
1532 {
1533 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1534 }
1535 else if (device_param->vendor_id == VENDOR_ID_NV)
1536 {
1537 #ifdef LINUX
1538 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1539 #else
1540 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "rpm", hm_get_fanspeed_with_device_id (device_id));
1541 #endif
1542 }
1543
1544 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1545 }
1546 else
1547 {
1548 char utilization[HM_STR_BUF_SIZE];
1549 char temperature[HM_STR_BUF_SIZE];
1550
1551 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1552 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1553
1554 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1555 }
1556 }
1557
1558 hc_thread_mutex_unlock (mux_adl);
1559 }
1560 }
1561
1562 static void status_benchmark ()
1563 {
1564 if (data.devices_status == STATUS_INIT) return;
1565 if (data.devices_status == STATUS_STARTING) return;
1566
1567 if (data.words_cnt == 0) return;
1568
1569 u64 speed_cnt[DEVICES_MAX];
1570 float speed_ms[DEVICES_MAX];
1571
1572 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1573 {
1574 hc_device_param_t *device_param = &data.devices_param[device_id];
1575
1576 if (device_param->skipped) continue;
1577
1578 speed_cnt[device_id] = 0;
1579 speed_ms[device_id] = 0;
1580
1581 for (int i = 0; i < SPEED_CACHE; i++)
1582 {
1583 speed_cnt[device_id] += device_param->speed_cnt[i];
1584 speed_ms[device_id] += device_param->speed_ms[i];
1585 }
1586
1587 speed_cnt[device_id] /= SPEED_CACHE;
1588 speed_ms[device_id] /= SPEED_CACHE;
1589 }
1590
1591 float hashes_all_ms = 0;
1592
1593 float hashes_dev_ms[DEVICES_MAX];
1594
1595 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1596 {
1597 hc_device_param_t *device_param = &data.devices_param[device_id];
1598
1599 if (device_param->skipped) continue;
1600
1601 hashes_dev_ms[device_id] = 0;
1602
1603 if (speed_ms[device_id])
1604 {
1605 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1606
1607 hashes_all_ms += hashes_dev_ms[device_id];
1608 }
1609 }
1610
1611 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1612 {
1613 hc_device_param_t *device_param = &data.devices_param[device_id];
1614
1615 if (device_param->skipped) continue;
1616
1617 char display_dev_cur[16] = { 0 };
1618
1619 strncpy (display_dev_cur, "0.00", 4);
1620
1621 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1622
1623 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1624 }
1625
1626 char display_all_cur[16] = { 0 };
1627
1628 strncpy (display_all_cur, "0.00", 4);
1629
1630 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1631
1632 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1633 }
1634
1635 /**
1636 * oclHashcat -only- functions
1637 */
1638
1639 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1640 {
1641 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1642 {
1643 if (attack_kern == ATTACK_KERN_STRAIGHT)
1644 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1645 else if (attack_kern == ATTACK_KERN_COMBI)
1646 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1647 else if (attack_kern == ATTACK_KERN_BF)
1648 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1649 }
1650 else
1651 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1652 }
1653
1654 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1655 {
1656 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1657 {
1658 if (attack_kern == ATTACK_KERN_STRAIGHT)
1659 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1660 else if (attack_kern == ATTACK_KERN_COMBI)
1661 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1662 else if (attack_kern == ATTACK_KERN_BF)
1663 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1664 }
1665 else
1666 {
1667 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1668 }
1669 }
1670
1671 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1672 {
1673 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1674 {
1675 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1676 }
1677 else
1678 {
1679 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1680 }
1681 }
1682
1683 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1684 {
1685 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1686 {
1687 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1688 }
1689 else
1690 {
1691 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1692 }
1693 }
1694
1695 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1696 {
1697 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1698 }
1699
1700 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1701 {
1702 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1703 }
1704
1705 static uint convert_from_hex (char *line_buf, const uint line_len)
1706 {
1707 if (line_len & 1) return (line_len); // not in hex
1708
1709 if (data.hex_wordlist == 1)
1710 {
1711 uint i;
1712 uint j;
1713
1714 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1715 {
1716 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1717 }
1718
1719 memset (line_buf + i, 0, line_len - i);
1720
1721 return (i);
1722 }
1723 else if (line_len >= 6) // $HEX[] = 6
1724 {
1725 if (line_buf[0] != '$') return (line_len);
1726 if (line_buf[1] != 'H') return (line_len);
1727 if (line_buf[2] != 'E') return (line_len);
1728 if (line_buf[3] != 'X') return (line_len);
1729 if (line_buf[4] != '[') return (line_len);
1730 if (line_buf[line_len - 1] != ']') return (line_len);
1731
1732 uint i;
1733 uint j;
1734
1735 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1736 {
1737 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1738 }
1739
1740 memset (line_buf + i, 0, line_len - i);
1741
1742 return (i);
1743 }
1744
1745 return (line_len);
1746 }
1747
1748 static uint count_lines (FILE *fd)
1749 {
1750 uint cnt = 0;
1751
1752 char *buf = (char *) mymalloc (BUFSIZ + 1);
1753
1754 size_t nread_tmp = 0;
1755
1756 char *ptr = buf;
1757
1758 while (!feof (fd))
1759 {
1760 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1761 nread_tmp = nread;
1762
1763 if (nread < 1) continue;
1764
1765 ptr = buf;
1766
1767 do
1768 {
1769 if (*ptr++ == '\n') cnt++;
1770
1771 } while (nread--);
1772 }
1773
1774 // special case (if last line did not contain a newline char ... at the very end of the file)
1775
1776 if (nread_tmp > 3)
1777 {
1778 ptr -= 2;
1779
1780 if (*ptr != '\n')
1781 {
1782 ptr--;
1783
1784 if (*ptr != '\n') // needed ? different on windows systems?
1785 {
1786 cnt++;
1787 }
1788 }
1789 }
1790
1791 myfree (buf);
1792
1793 return cnt;
1794 }
1795
1796 static void clear_prompt ()
1797 {
1798 fputc ('\r', stdout);
1799
1800 for (size_t i = 0; i < strlen (PROMPT); i++)
1801 {
1802 fputc (' ', stdout);
1803 }
1804
1805 fputc ('\r', stdout);
1806
1807 fflush (stdout);
1808 }
1809
1810 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1811 {
1812 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1813 }
1814
1815 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1816 {
1817 char *outfile = data.outfile;
1818 uint quiet = data.quiet;
1819 FILE *pot_fp = data.pot_fp;
1820 uint loopback = data.loopback;
1821 uint debug_mode = data.debug_mode;
1822 char *debug_file = data.debug_file;
1823
1824 char debug_rule_buf[BLOCK_SIZE];
1825 int debug_rule_len = 0; // -1 error
1826 uint debug_plain_len = 0;
1827
1828 u8 debug_plain_ptr[BLOCK_SIZE];
1829
1830 // hash
1831
1832 char out_buf[4096] = { 0 };
1833
1834 ascii_digest (out_buf, salt_pos, digest_pos);
1835
1836 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1837
1838 // plain
1839
1840 plain_t plain;
1841
1842 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1843
1844 uint gidvid = plain.gidvid;
1845 uint il_pos = plain.il_pos;
1846
1847 u64 crackpos = device_param->words_off;
1848
1849 uint plain_buf[16];
1850
1851 u8 *plain_ptr = (u8 *) plain_buf;
1852 unsigned int plain_len = 0;
1853
1854 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1855 {
1856 u64 gidd = gidvid;
1857 u64 gidm = 0;
1858
1859 pw_t pw;
1860
1861 gidd_to_pw_t (device_param, gidd, &pw);
1862
1863 for (int i = 0, j = gidm; i < 16; i++, j++)
1864 {
1865 plain_buf[i] = pw.hi1[0][j];
1866 }
1867
1868 plain_len = pw.pw_len;
1869
1870 const uint off = device_param->innerloop_pos + il_pos;
1871
1872 if (debug_mode > 0)
1873 {
1874 debug_rule_len = 0;
1875
1876 // save rule
1877 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1878 {
1879 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1880
1881 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1882 }
1883
1884 // save plain
1885 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1886 {
1887 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1888
1889 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1890
1891 debug_plain_len = plain_len;
1892 }
1893 }
1894
1895 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1896
1897 crackpos += gidvid;
1898 crackpos *= data.kernel_rules_cnt;
1899 crackpos += device_param->innerloop_pos + il_pos;
1900
1901 if (plain_len > data.pw_max) plain_len = data.pw_max;
1902 }
1903 else if (data.attack_mode == ATTACK_MODE_COMBI)
1904 {
1905 u64 gidd = gidvid;
1906 u64 gidm = 0;
1907
1908 pw_t pw;
1909
1910 gidd_to_pw_t (device_param, gidd, &pw);
1911
1912 for (int i = 0, j = gidm; i < 16; i++, j++)
1913 {
1914 plain_buf[i] = pw.hi1[0][j];
1915 }
1916
1917 plain_len = pw.pw_len;
1918
1919 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1920 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1921
1922 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1923 {
1924 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1925 }
1926 else
1927 {
1928 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1929
1930 memcpy (plain_ptr, comb_buf, comb_len);
1931 }
1932
1933 plain_len += comb_len;
1934
1935 crackpos += gidvid;
1936 crackpos *= data.combs_cnt;
1937 crackpos += device_param->innerloop_pos + il_pos;
1938
1939 if (data.pw_max != PW_DICTMAX1)
1940 {
1941 if (plain_len > data.pw_max) plain_len = data.pw_max;
1942 }
1943 }
1944 else if (data.attack_mode == ATTACK_MODE_BF)
1945 {
1946 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1947 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1948
1949 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1950 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1951
1952 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1953 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1954
1955 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1956 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1957
1958 plain_len = data.css_cnt;
1959
1960 crackpos += gidvid;
1961 crackpos *= data.bfs_cnt;
1962 crackpos += device_param->innerloop_pos + il_pos;
1963 }
1964 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1965 {
1966 u64 gidd = gidvid;
1967 u64 gidm = 0;
1968
1969 pw_t pw;
1970
1971 gidd_to_pw_t (device_param, gidd, &pw);
1972
1973 for (int i = 0, j = gidm; i < 16; i++, j++)
1974 {
1975 plain_buf[i] = pw.hi1[0][j];
1976 }
1977
1978 plain_len = pw.pw_len;
1979
1980 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1981
1982 uint start = 0;
1983 uint stop = device_param->kernel_params_mp_buf32[4];
1984
1985 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1986
1987 plain_len += start + stop;
1988
1989 crackpos += gidvid;
1990 crackpos *= data.combs_cnt;
1991 crackpos += device_param->innerloop_pos + il_pos;
1992
1993 if (data.pw_max != PW_DICTMAX1)
1994 {
1995 if (plain_len > data.pw_max) plain_len = data.pw_max;
1996 }
1997 }
1998 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1999 {
2000 u64 gidd = gidvid;
2001 u64 gidm = 0;
2002
2003 pw_t pw;
2004
2005 gidd_to_pw_t (device_param, gidd, &pw);
2006
2007 for (int i = 0, j = gidm; i < 16; i++, j++)
2008 {
2009 plain_buf[i] = pw.hi1[0][j];
2010 }
2011
2012 plain_len = pw.pw_len;
2013
2014 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2015
2016 uint start = 0;
2017 uint stop = device_param->kernel_params_mp_buf32[4];
2018
2019 memmove (plain_ptr + stop, plain_ptr, plain_len);
2020
2021 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2022
2023 plain_len += start + stop;
2024
2025 crackpos += gidvid;
2026 crackpos *= data.combs_cnt;
2027 crackpos += device_param->innerloop_pos + il_pos;
2028
2029 if (data.pw_max != PW_DICTMAX1)
2030 {
2031 if (plain_len > data.pw_max) plain_len = data.pw_max;
2032 }
2033 }
2034
2035 if (data.attack_mode == ATTACK_MODE_BF)
2036 {
2037 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2038 {
2039 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2040 {
2041 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2042 {
2043 plain_len = plain_len - data.salts_buf[0].salt_len;
2044 }
2045 }
2046
2047 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2048 {
2049 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2050 {
2051 plain_ptr[j] = plain_ptr[i];
2052 }
2053
2054 plain_len = plain_len / 2;
2055 }
2056 }
2057 }
2058
2059 // if enabled, update also the potfile
2060
2061 if (pot_fp)
2062 {
2063 fprintf (pot_fp, "%s:", out_buf);
2064
2065 format_plain (pot_fp, plain_ptr, plain_len, 1);
2066
2067 fputc ('\n', pot_fp);
2068
2069 fflush (pot_fp);
2070 }
2071
2072 // outfile
2073
2074 FILE *out_fp = NULL;
2075
2076 if (outfile != NULL)
2077 {
2078 if ((out_fp = fopen (outfile, "ab")) == NULL)
2079 {
2080 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2081
2082 out_fp = stdout;
2083 }
2084 }
2085 else
2086 {
2087 out_fp = stdout;
2088
2089 if (quiet == 0) clear_prompt ();
2090 }
2091
2092 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2093
2094 if (outfile != NULL)
2095 {
2096 if (out_fp != stdout)
2097 {
2098 fclose (out_fp);
2099 }
2100 }
2101 else
2102 {
2103 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2104 {
2105 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2106 {
2107 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2108 if (quiet == 0) fflush (stdout);
2109 }
2110 }
2111 }
2112
2113 // loopback
2114
2115 if (loopback)
2116 {
2117 char *loopback_file = data.loopback_file;
2118
2119 FILE *fb_fp = NULL;
2120
2121 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2122 {
2123 format_plain (fb_fp, plain_ptr, plain_len, 1);
2124
2125 fputc ('\n', fb_fp);
2126
2127 fclose (fb_fp);
2128 }
2129 }
2130
2131 // (rule) debug mode
2132
2133 // the next check implies that:
2134 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2135 // - debug_mode > 0
2136
2137 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2138 {
2139 if (debug_rule_len < 0) debug_rule_len = 0;
2140
2141 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2142
2143 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2144
2145 if ((quiet == 0) && (debug_file == NULL))
2146 {
2147 fprintf (stdout, "%s", PROMPT);
2148 fflush (stdout);
2149 }
2150 }
2151 }
2152
2153 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2154 {
2155 salt_t *salt_buf = &data.salts_buf[salt_pos];
2156
2157 int found = 0;
2158
2159 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2160
2161 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2162
2163 if (found == 1)
2164 {
2165 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2166
2167 log_info_nn ("");
2168
2169 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2170
2171 uint cpt_cracked = 0;
2172
2173 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2174 {
2175 uint idx = salt_buf->digests_offset + digest_pos;
2176
2177 if (data.digests_shown_tmp[idx] == 0) continue;
2178
2179 if (data.digests_shown[idx] == 1) continue;
2180
2181 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2182 {
2183 data.digests_shown[idx] = 1;
2184
2185 data.digests_done++;
2186
2187 cpt_cracked++;
2188
2189 salt_buf->digests_done++;
2190
2191 if (salt_buf->digests_done == salt_buf->digests_cnt)
2192 {
2193 data.salts_shown[salt_pos] = 1;
2194
2195 data.salts_done++;
2196 }
2197 }
2198
2199 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2200
2201 check_hash (device_param, salt_pos, digest_pos);
2202 }
2203
2204 if (cpt_cracked > 0)
2205 {
2206 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2207 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2208
2209 data.cpt_pos++;
2210
2211 data.cpt_total += cpt_cracked;
2212
2213 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2214 }
2215
2216 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2217 {
2218 // we need to reset cracked state on the device
2219 // otherwise host thinks again and again the hash was cracked
2220 // and returns invalid password each time
2221
2222 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2223
2224 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2225 }
2226
2227 memset (device_param->result, 0, device_param->size_results);
2228
2229 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2230 }
2231 }
2232
2233 static void save_hash ()
2234 {
2235 char *hashfile = data.hashfile;
2236
2237 char new_hashfile[256] = { 0 };
2238 char old_hashfile[256] = { 0 };
2239
2240 snprintf (new_hashfile, 255, "%s.new", hashfile);
2241 snprintf (old_hashfile, 255, "%s.old", hashfile);
2242
2243 unlink (new_hashfile);
2244
2245 char separator = data.separator;
2246
2247 FILE *fp = fopen (new_hashfile, "wb");
2248
2249 if (fp == NULL)
2250 {
2251 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2252
2253 exit (-1);
2254 }
2255
2256 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2257 {
2258 if (data.salts_shown[salt_pos] == 1) continue;
2259
2260 salt_t *salt_buf = &data.salts_buf[salt_pos];
2261
2262 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2263 {
2264 uint idx = salt_buf->digests_offset + digest_pos;
2265
2266 if (data.digests_shown[idx] == 1) continue;
2267
2268 if (data.hash_mode != 2500)
2269 {
2270 char out_buf[4096] = { 0 };
2271
2272 if (data.username == 1)
2273 {
2274 user_t *user = data.hash_info[idx]->user;
2275
2276 uint i;
2277
2278 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2279
2280 fputc (separator, fp);
2281 }
2282
2283 ascii_digest (out_buf, salt_pos, digest_pos);
2284
2285 fputs (out_buf, fp);
2286
2287 log_out (fp, "");
2288 }
2289 else
2290 {
2291 hccap_t hccap;
2292
2293 to_hccap_t (&hccap, salt_pos, digest_pos);
2294
2295 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2296 }
2297 }
2298 }
2299
2300 fflush (fp);
2301
2302 fclose (fp);
2303
2304 unlink (old_hashfile);
2305
2306 if (rename (hashfile, old_hashfile) != 0)
2307 {
2308 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2309
2310 exit (-1);
2311 }
2312
2313 unlink (hashfile);
2314
2315 if (rename (new_hashfile, hashfile) != 0)
2316 {
2317 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2318
2319 exit (-1);
2320 }
2321
2322 unlink (old_hashfile);
2323 }
2324
2325 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2326 {
2327 // function called only in case kernel_blocks_all > words_left)
2328
2329 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2330
2331 kernel_blocks_div += kernel_blocks_div / 100;
2332
2333 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2334
2335 while (kernel_blocks_new < total_left)
2336 {
2337 kernel_blocks_div += kernel_blocks_div / 100;
2338
2339 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2340 }
2341
2342 if (data.quiet == 0)
2343 {
2344 clear_prompt ();
2345
2346 log_info ("");
2347
2348 log_info ("INFO: approaching final keyspace, workload adjusted");
2349
2350 log_info ("");
2351
2352 fprintf (stdout, "%s", PROMPT);
2353
2354 fflush (stdout);
2355 }
2356
2357 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2358
2359 return kernel_blocks_div;
2360 }
2361
2362 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2363 {
2364 uint num_elements = num;
2365
2366 device_param->kernel_params_buf32[30] = data.combs_mode;
2367 device_param->kernel_params_buf32[31] = num;
2368
2369 uint kernel_threads = device_param->kernel_threads;
2370
2371 while (num_elements % kernel_threads) num_elements++;
2372
2373 cl_kernel kernel = NULL;
2374
2375 switch (kern_run)
2376 {
2377 case KERN_RUN_1: kernel = device_param->kernel1; break;
2378 case KERN_RUN_12: kernel = device_param->kernel12; break;
2379 case KERN_RUN_2: kernel = device_param->kernel2; break;
2380 case KERN_RUN_23: kernel = device_param->kernel23; break;
2381 case KERN_RUN_3: kernel = device_param->kernel3; break;
2382 }
2383
2384 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2385 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2386 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2387 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2388 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2389 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2390 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2391 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2392 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2393 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2394 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2395
2396 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2397 {
2398 const size_t global_work_size[3] = { num_elements, 32, 1 };
2399 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2400
2401 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2402 }
2403 else
2404 {
2405 const size_t global_work_size[3] = { num_elements, 1, 1 };
2406 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2407
2408 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2409 }
2410
2411 hc_clFlush (device_param->command_queue);
2412
2413 hc_clFinish (device_param->command_queue);
2414 }
2415
2416 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2417 {
2418 uint num_elements = num;
2419
2420 switch (kern_run)
2421 {
2422 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2423 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2424 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2425 }
2426
2427 // causes problems with special threads like in bcrypt
2428 // const uint kernel_threads = device_param->kernel_threads;
2429
2430 const uint kernel_threads = KERNEL_THREADS;
2431
2432 while (num_elements % kernel_threads) num_elements++;
2433
2434 cl_kernel kernel = NULL;
2435
2436 switch (kern_run)
2437 {
2438 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2439 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2440 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2441 }
2442
2443 switch (kern_run)
2444 {
2445 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2446 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2447 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2448 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2449 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2450 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2451 break;
2452 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2453 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2454 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2455 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2456 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2457 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2458 break;
2459 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2460 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2461 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2462 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2463 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2464 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2465 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2466 break;
2467 }
2468
2469 const size_t global_work_size[3] = { num_elements, 1, 1 };
2470 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2471
2472 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2473
2474 hc_clFlush (device_param->command_queue);
2475
2476 hc_clFinish (device_param->command_queue);
2477 }
2478
2479 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2480 {
2481 uint num_elements = num;
2482
2483 uint kernel_threads = device_param->kernel_threads;
2484
2485 while (num_elements % kernel_threads) num_elements++;
2486
2487 cl_kernel kernel = device_param->kernel_tb;
2488
2489 const size_t global_work_size[3] = { num_elements, 1, 1 };
2490 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2491
2492 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2493
2494 hc_clFlush (device_param->command_queue);
2495
2496 hc_clFinish (device_param->command_queue);
2497 }
2498
2499 static void run_kernel_tm (hc_device_param_t *device_param)
2500 {
2501 const uint num_elements = 1024; // fixed
2502
2503 const uint kernel_threads = 32;
2504
2505 cl_kernel kernel = device_param->kernel_tm;
2506
2507 const size_t global_work_size[3] = { num_elements, 1, 1 };
2508 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2509
2510 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2511
2512 hc_clFlush (device_param->command_queue);
2513
2514 hc_clFinish (device_param->command_queue);
2515 }
2516
2517 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2518 {
2519 uint num_elements = num;
2520
2521 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2522 device_param->kernel_params_amp_buf32[6] = num_elements;
2523
2524 // causes problems with special threads like in bcrypt
2525 // const uint kernel_threads = device_param->kernel_threads;
2526
2527 const uint kernel_threads = KERNEL_THREADS;
2528
2529 while (num_elements % kernel_threads) num_elements++;
2530
2531 cl_kernel kernel = device_param->kernel_amp;
2532
2533 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2534 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2535
2536 const size_t global_work_size[3] = { num_elements, 1, 1 };
2537 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2538
2539 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2540
2541 hc_clFlush (device_param->command_queue);
2542
2543 hc_clFinish (device_param->command_queue);
2544 }
2545
2546 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2547 {
2548 if (device_param->vendor_id == VENDOR_ID_AMD)
2549 {
2550 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2551
2552 const cl_uchar zero = 0;
2553
2554 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2555 }
2556 else
2557 {
2558 // NOTE: clEnqueueFillBuffer () always fails with -59
2559 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults
2560 // How's that possible, OpenCL 1.2 support is advertised??
2561 // We need to workaround...
2562
2563 #define FILLSZ 0x100000
2564
2565 char *tmp = (char *) mymalloc (FILLSZ);
2566
2567 memset (tmp, 0, FILLSZ);
2568
2569 for (uint i = 0; i < size; i += FILLSZ)
2570 {
2571 const int left = size - i;
2572
2573 const int fillsz = MIN (FILLSZ, left);
2574
2575 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2576 }
2577
2578 myfree (tmp);
2579 }
2580 }
2581
2582 static int run_rule_engine (const int rule_len, const char *rule_buf)
2583 {
2584 if (rule_len == 0)
2585 {
2586 return 0;
2587 }
2588 else if (rule_len == 1)
2589 {
2590 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2591 }
2592
2593 return 1;
2594 }
2595
2596 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2597 {
2598 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2599 {
2600 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2601 }
2602 else if (data.attack_kern == ATTACK_KERN_COMBI)
2603 {
2604 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2605 }
2606 else if (data.attack_kern == ATTACK_KERN_BF)
2607 {
2608 const u64 off = device_param->words_off;
2609
2610 device_param->kernel_params_mp_l_buf64[3] = off;
2611
2612 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2613 }
2614 }
2615
2616 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2617 {
2618 const uint kernel_loops = data.kernel_loops;
2619
2620 // init speed timer
2621
2622 uint speed_pos = device_param->speed_pos;
2623
2624 #ifdef _POSIX
2625 if (device_param->timer_speed.tv_sec == 0)
2626 {
2627 hc_timer_set (&device_param->timer_speed);
2628 }
2629 #endif
2630
2631 #ifdef _WIN
2632 if (device_param->timer_speed.QuadPart == 0)
2633 {
2634 hc_timer_set (&device_param->timer_speed);
2635 }
2636 #endif
2637
2638 // find higest password length, this is for optimization stuff
2639
2640 uint highest_pw_len = 0;
2641
2642 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2643 {
2644 }
2645 else if (data.attack_kern == ATTACK_KERN_COMBI)
2646 {
2647 }
2648 else if (data.attack_kern == ATTACK_KERN_BF)
2649 {
2650 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2651 + device_param->kernel_params_mp_l_buf32[5];
2652 }
2653
2654 // bitslice optimization stuff
2655
2656 if (data.attack_mode == ATTACK_MODE_BF)
2657 {
2658 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2659 {
2660 run_kernel_tb (device_param, pws_cnt);
2661 }
2662 }
2663
2664 // iteration type
2665
2666 uint innerloop_step = 0;
2667 uint innerloop_cnt = 0;
2668
2669 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2670 else innerloop_step = 1;
2671
2672 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2673 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2674 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2675
2676 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2677
2678 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2679 {
2680 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2681
2682 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2683
2684 if (data.devices_status == STATUS_CRACKED) break;
2685 if (data.devices_status == STATUS_ABORTED) break;
2686 if (data.devices_status == STATUS_QUIT) break;
2687 if (data.devices_status == STATUS_BYPASS) break;
2688
2689 if (data.salts_shown[salt_pos] == 1) continue;
2690
2691 salt_t *salt_buf = &data.salts_buf[salt_pos];
2692
2693 device_param->kernel_params_buf32[24] = salt_pos;
2694 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2695 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2696
2697 FILE *combs_fp = device_param->combs_fp;
2698
2699 if (data.attack_mode == ATTACK_MODE_COMBI)
2700 {
2701 rewind (combs_fp);
2702 }
2703
2704 // innerloops
2705
2706 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2707 {
2708 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2709
2710 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2711
2712 if (data.devices_status == STATUS_CRACKED) break;
2713 if (data.devices_status == STATUS_ABORTED) break;
2714 if (data.devices_status == STATUS_QUIT) break;
2715 if (data.devices_status == STATUS_BYPASS) break;
2716
2717 uint innerloop_left = innerloop_cnt - innerloop_pos;
2718
2719 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2720
2721 device_param->innerloop_pos = innerloop_pos;
2722 device_param->innerloop_left = innerloop_left;
2723
2724 device_param->kernel_params_buf32[27] = innerloop_left;
2725
2726 if (innerloop_left == 0) continue;
2727
2728 // initialize amplifiers
2729
2730 if (data.attack_mode == ATTACK_MODE_COMBI)
2731 {
2732 char line_buf[BUFSIZ];
2733
2734 uint i = 0;
2735
2736 while (i < innerloop_left)
2737 {
2738 if (feof (combs_fp)) break;
2739
2740 int line_len = fgetl (combs_fp, line_buf);
2741
2742 if (line_len >= PW_MAX1) continue;
2743
2744 line_len = convert_from_hex (line_buf, line_len);
2745
2746 char *line_buf_new = line_buf;
2747
2748 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2749 {
2750 char rule_buf_out[BLOCK_SIZE] = { 0 };
2751
2752 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2753
2754 if (rule_len_out < 0)
2755 {
2756 data.words_progress_rejected[salt_pos] += pw_cnt;
2757
2758 continue;
2759 }
2760
2761 line_len = rule_len_out;
2762
2763 line_buf_new = rule_buf_out;
2764 }
2765
2766 line_len = MIN (line_len, PW_DICTMAX);
2767
2768 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2769
2770 memcpy (ptr, line_buf_new, line_len);
2771
2772 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2773
2774 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2775 {
2776 uppercase (ptr, line_len);
2777 }
2778
2779 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2780 {
2781 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2782 {
2783 ptr[line_len] = 0x80;
2784 }
2785
2786 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2787 {
2788 ptr[line_len] = 0x01;
2789 }
2790 }
2791
2792 device_param->combs_buf[i].pw_len = line_len;
2793
2794 i++;
2795 }
2796
2797 for (uint j = i; j < innerloop_left; j++)
2798 {
2799 device_param->combs_buf[j].i[0] = 0;
2800 device_param->combs_buf[j].i[1] = 0;
2801 device_param->combs_buf[j].i[2] = 0;
2802 device_param->combs_buf[j].i[3] = 0;
2803 device_param->combs_buf[j].i[4] = 0;
2804 device_param->combs_buf[j].i[5] = 0;
2805 device_param->combs_buf[j].i[6] = 0;
2806 device_param->combs_buf[j].i[7] = 0;
2807
2808 device_param->combs_buf[j].pw_len = 0;
2809 }
2810
2811 innerloop_left = i;
2812 }
2813 else if (data.attack_mode == ATTACK_MODE_BF)
2814 {
2815 u64 off = innerloop_pos;
2816
2817 device_param->kernel_params_mp_r_buf64[3] = off;
2818
2819 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2820 }
2821 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2822 {
2823 u64 off = innerloop_pos;
2824
2825 device_param->kernel_params_mp_buf64[3] = off;
2826
2827 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2828 }
2829 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2830 {
2831 u64 off = innerloop_pos;
2832
2833 device_param->kernel_params_mp_buf64[3] = off;
2834
2835 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2836 }
2837
2838 // copy amplifiers
2839
2840 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2841 {
2842 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
2843 }
2844 else if (data.attack_mode == ATTACK_MODE_COMBI)
2845 {
2846 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
2847 }
2848 else if (data.attack_mode == ATTACK_MODE_BF)
2849 {
2850 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
2851 }
2852 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2853 {
2854 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2855 }
2856 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2857 {
2858 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2859 }
2860
2861 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2862 {
2863 if (data.attack_mode == ATTACK_MODE_BF)
2864 {
2865 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2866 {
2867 const uint size_tm = 32 * sizeof (bs_word_t);
2868
2869 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2870
2871 run_kernel_tm (device_param);
2872
2873 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2874 }
2875 }
2876
2877 if (highest_pw_len < 16)
2878 {
2879 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2880 }
2881 else if (highest_pw_len < 32)
2882 {
2883 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2884 }
2885 else
2886 {
2887 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2888 }
2889 }
2890 else
2891 {
2892 run_kernel_amp (device_param, pws_cnt);
2893
2894 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2895
2896 if (data.opts_type & OPTS_TYPE_HOOK12)
2897 {
2898 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2899 }
2900
2901 uint iter = salt_buf->salt_iter;
2902
2903 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2904 {
2905 uint loop_left = iter - loop_pos;
2906
2907 loop_left = MIN (loop_left, kernel_loops);
2908
2909 device_param->kernel_params_buf32[25] = loop_pos;
2910 device_param->kernel_params_buf32[26] = loop_left;
2911
2912 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2913
2914 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2915
2916 if (data.devices_status == STATUS_CRACKED) break;
2917 if (data.devices_status == STATUS_ABORTED) break;
2918 if (data.devices_status == STATUS_QUIT) break;
2919 }
2920
2921 if (data.opts_type & OPTS_TYPE_HOOK23)
2922 {
2923 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2924
2925 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2926
2927 // do something with data
2928
2929 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2930 }
2931
2932 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2933 }
2934
2935 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2936
2937 if (data.devices_status == STATUS_CRACKED) break;
2938 if (data.devices_status == STATUS_ABORTED) break;
2939 if (data.devices_status == STATUS_QUIT) break;
2940
2941 /**
2942 * result
2943 */
2944
2945 hc_thread_mutex_lock (mux_display);
2946
2947 check_cracked (device_param, salt_pos);
2948
2949 hc_thread_mutex_unlock (mux_display);
2950
2951 /**
2952 * progress
2953 */
2954
2955 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
2956
2957 hc_thread_mutex_lock (mux_counter);
2958
2959 data.words_progress_done[salt_pos] += perf_sum_all;
2960
2961 hc_thread_mutex_unlock (mux_counter);
2962
2963 /**
2964 * speed
2965 */
2966
2967 float speed_ms;
2968
2969 hc_timer_get (device_param->timer_speed, speed_ms);
2970
2971 hc_timer_set (&device_param->timer_speed);
2972
2973 hc_thread_mutex_lock (mux_display);
2974
2975 device_param->speed_cnt[speed_pos] = perf_sum_all;
2976
2977 device_param->speed_ms[speed_pos] = speed_ms;
2978
2979 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2980
2981 hc_thread_mutex_unlock (mux_display);
2982
2983 speed_pos++;
2984
2985 if (speed_pos == SPEED_CACHE)
2986 {
2987 speed_pos = 0;
2988 }
2989 }
2990 }
2991
2992 device_param->speed_pos = speed_pos;
2993 }
2994
2995 static void load_segment (wl_data_t *wl_data, FILE *fd)
2996 {
2997 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2998
2999 wl_data->pos = 0;
3000
3001 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3002
3003 wl_data->buf[wl_data->cnt] = 0;
3004
3005 if (wl_data->cnt == 0) return;
3006
3007 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3008
3009 while (!feof (fd))
3010 {
3011 if (wl_data->cnt == wl_data->avail)
3012 {
3013 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3014
3015 wl_data->avail += wl_data->incr;
3016 }
3017
3018 const int c = fgetc (fd);
3019
3020 if (c == EOF) break;
3021
3022 wl_data->buf[wl_data->cnt] = (char) c;
3023
3024 wl_data->cnt++;
3025
3026 if (c == '\n') break;
3027 }
3028
3029 // ensure stream ends with a newline
3030
3031 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3032 {
3033 wl_data->cnt++;
3034
3035 wl_data->buf[wl_data->cnt - 1] = '\n';
3036 }
3037
3038 return;
3039 }
3040
3041 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3042 {
3043 char *ptr = buf;
3044
3045 for (u32 i = 0; i < sz; i++, ptr++)
3046 {
3047 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3048
3049 if (i == 7)
3050 {
3051 *off = i;
3052 *len = i;
3053
3054 return;
3055 }
3056
3057 if (*ptr != '\n') continue;
3058
3059 *off = i + 1;
3060
3061 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3062
3063 *len = i;
3064
3065 return;
3066 }
3067
3068 *off = sz;
3069 *len = sz;
3070 }
3071
3072 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3073 {
3074 char *ptr = buf;
3075
3076 for (u32 i = 0; i < sz; i++, ptr++)
3077 {
3078 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3079
3080 if (*ptr != '\n') continue;
3081
3082 *off = i + 1;
3083
3084 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3085
3086 *len = i;
3087
3088 return;
3089 }
3090
3091 *off = sz;
3092 *len = sz;
3093 }
3094
3095 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3096 {
3097 char *ptr = buf;
3098
3099 for (u32 i = 0; i < sz; i++, ptr++)
3100 {
3101 if (*ptr != '\n') continue;
3102
3103 *off = i + 1;
3104
3105 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3106
3107 *len = i;
3108
3109 return;
3110 }
3111
3112 *off = sz;
3113 *len = sz;
3114 }
3115
3116 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3117 {
3118 while (wl_data->pos < wl_data->cnt)
3119 {
3120 uint off;
3121 uint len;
3122
3123 char *ptr = wl_data->buf + wl_data->pos;
3124
3125 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3126
3127 wl_data->pos += off;
3128
3129 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3130 {
3131 char rule_buf_out[BLOCK_SIZE] = { 0 };
3132
3133 int rule_len_out = -1;
3134
3135 if (len < BLOCK_SIZE)
3136 {
3137 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3138 }
3139
3140 if (rule_len_out < 0)
3141 {
3142 continue;
3143 }
3144
3145 if (rule_len_out > PW_MAX)
3146 {
3147 continue;
3148 }
3149 }
3150 else
3151 {
3152 if (len > PW_MAX)
3153 {
3154 continue;
3155 }
3156 }
3157
3158 *out_buf = ptr;
3159 *out_len = len;
3160
3161 return;
3162 }
3163
3164 if (feof (fd))
3165 {
3166 fprintf (stderr, "bug!!\n");
3167
3168 return;
3169 }
3170
3171 load_segment (wl_data, fd);
3172
3173 get_next_word (wl_data, fd, out_buf, out_len);
3174 }
3175
3176 #ifdef _POSIX
3177 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3178 #endif
3179
3180 #ifdef _WIN
3181 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3182 #endif
3183 {
3184 hc_signal (NULL);
3185
3186 dictstat_t d;
3187
3188 d.cnt = 0;
3189
3190 #ifdef _POSIX
3191 fstat (fileno (fd), &d.stat);
3192 #endif
3193
3194 #ifdef _WIN
3195 _fstat64 (fileno (fd), &d.stat);
3196 #endif
3197
3198 d.stat.st_mode = 0;
3199 d.stat.st_nlink = 0;
3200 d.stat.st_uid = 0;
3201 d.stat.st_gid = 0;
3202 d.stat.st_rdev = 0;
3203 d.stat.st_atime = 0;
3204
3205 #ifdef _POSIX
3206 d.stat.st_blksize = 0;
3207 d.stat.st_blocks = 0;
3208 #endif
3209
3210 if (d.stat.st_size == 0) return 0;
3211
3212 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3213
3214 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3215 {
3216 if (d_cache)
3217 {
3218 u64 cnt = d_cache->cnt;
3219
3220 u64 keyspace = cnt;
3221
3222 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3223 {
3224 keyspace *= data.kernel_rules_cnt;
3225 }
3226 else if (data.attack_kern == ATTACK_KERN_COMBI)
3227 {
3228 keyspace *= data.combs_cnt;
3229 }
3230
3231 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3232 if (data.quiet == 0) log_info ("");
3233
3234 hc_signal (sigHandler_default);
3235
3236 return (keyspace);
3237 }
3238 }
3239
3240 time_t now = 0;
3241 time_t prev = 0;
3242
3243 u64 comp = 0;
3244 u64 cnt = 0;
3245 u64 cnt2 = 0;
3246
3247 while (!feof (fd))
3248 {
3249 load_segment (wl_data, fd);
3250
3251 comp += wl_data->cnt;
3252
3253 u32 i = 0;
3254
3255 while (i < wl_data->cnt)
3256 {
3257 u32 len;
3258 u32 off;
3259
3260 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3261
3262 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3263 {
3264 char rule_buf_out[BLOCK_SIZE] = { 0 };
3265
3266 int rule_len_out = -1;
3267
3268 if (len < BLOCK_SIZE)
3269 {
3270 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3271 }
3272
3273 if (rule_len_out < 0)
3274 {
3275 len = PW_MAX1;
3276 }
3277 else
3278 {
3279 len = rule_len_out;
3280 }
3281 }
3282
3283 if (len < PW_MAX1)
3284 {
3285 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3286 {
3287 cnt += data.kernel_rules_cnt;
3288 }
3289 else if (data.attack_kern == ATTACK_KERN_COMBI)
3290 {
3291 cnt += data.combs_cnt;
3292 }
3293
3294 d.cnt++;
3295 }
3296
3297 i += off;
3298
3299 cnt2++;
3300 }
3301
3302 time (&now);
3303
3304 if ((now - prev) == 0) continue;
3305
3306 float percent = (float) comp / (float) d.stat.st_size;
3307
3308 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3309
3310 time (&prev);
3311 }
3312
3313 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3314 if (data.quiet == 0) log_info ("");
3315
3316 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3317
3318 hc_signal (sigHandler_default);
3319
3320 return (cnt);
3321 }
3322
3323 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3324 {
3325 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3326 }
3327
3328 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3329 {
3330 if (data.devices_status == STATUS_BYPASS) return 0;
3331
3332 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3333
3334 uint cache_cnt = pw_cache->cnt;
3335
3336 u8 *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3337
3338 memcpy (pw_hc1, pw_buf, pw_len);
3339
3340 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3341
3342 uint pws_cnt = device_param->pws_cnt;
3343
3344 cache_cnt++;
3345
3346 pw_t *pw = device_param->pws_buf + pws_cnt;
3347
3348 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3349
3350 pw->pw_len = pw_len;
3351
3352 pws_cnt++;
3353
3354 device_param->pws_cnt = pws_cnt;
3355 device_param->pw_cnt = pws_cnt * 1;
3356
3357 cache_cnt = 0;
3358
3359 pw_cache->cnt = cache_cnt;
3360
3361 return pws_cnt;
3362 }
3363
3364 static void *thread_monitor (void *p)
3365 {
3366 uint runtime_check = 0;
3367 uint remove_check = 0;
3368 uint status_check = 0;
3369 uint hwmon_check = 0;
3370 uint restore_check = 0;
3371
3372 uint restore_left = data.restore_timer;
3373 uint remove_left = data.remove_timer;
3374 uint status_left = data.status_timer;
3375
3376 // these variables are mainly used for fan control (AMD only)
3377
3378 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3379
3380 // temperature controller "loopback" values
3381
3382 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3383 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3384
3385 int temp_threshold = 1; // degrees celcius
3386
3387 int fan_speed_min = 15; // in percentage
3388 int fan_speed_max = 100;
3389
3390 time_t last_temp_check_time;
3391
3392 uint sleep_time = 1;
3393
3394 if (data.runtime)
3395 {
3396 runtime_check = 1;
3397 }
3398
3399 if (data.restore_timer)
3400 {
3401 restore_check = 1;
3402 }
3403
3404 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3405 {
3406 remove_check = 1;
3407 }
3408
3409 if (data.status == 1)
3410 {
3411 status_check = 1;
3412 }
3413
3414 if (data.gpu_temp_disable == 0)
3415 {
3416 time (&last_temp_check_time);
3417
3418 hwmon_check = 1;
3419 }
3420
3421 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3422 {
3423 return (p);
3424 }
3425
3426 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3427 {
3428 hc_sleep (sleep_time);
3429
3430 if (data.devices_status != STATUS_RUNNING) continue;
3431
3432 if (hwmon_check == 1)
3433 {
3434 hc_thread_mutex_lock (mux_adl);
3435
3436 time_t temp_check_time;
3437
3438 time (&temp_check_time);
3439
3440 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3441
3442 if (Ta == 0) Ta = 1;
3443
3444 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3445 {
3446 hc_device_param_t *device_param = &data.devices_param[device_id];
3447
3448 if (device_param->skipped) continue;
3449
3450 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3451
3452 const int temperature = hm_get_temperature_with_device_id (device_id);
3453
3454 if (temperature > (int) data.gpu_temp_abort)
3455 {
3456 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3457
3458 if (data.devices_status != STATUS_QUIT) myabort ();
3459
3460 break;
3461 }
3462
3463 const int gpu_temp_retain = data.gpu_temp_retain;
3464
3465 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3466 {
3467 if (data.hm_device[device_id].fan_supported == 1)
3468 {
3469 int temp_cur = temperature;
3470
3471 int temp_diff_new = gpu_temp_retain - temp_cur;
3472
3473 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3474
3475 // calculate Ta value (time difference in seconds between the last check and this check)
3476
3477 last_temp_check_time = temp_check_time;
3478
3479 float Kp = 1.8;
3480 float Ki = 0.005;
3481 float Kd = 6;
3482
3483 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3484
3485 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
3486
3487 if (abs (fan_diff_required) >= temp_threshold)
3488 {
3489 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3490
3491 int fan_speed_level = fan_speed_cur;
3492
3493 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3494
3495 int fan_speed_new = fan_speed_level - fan_diff_required;
3496
3497 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3498 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3499
3500 if (fan_speed_new != fan_speed_cur)
3501 {
3502 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3503 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3504
3505 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3506 {
3507 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3508
3509 fan_speed_chgd[device_id] = 1;
3510 }
3511
3512 temp_diff_old[device_id] = temp_diff_new;
3513 }
3514 }
3515 }
3516 }
3517 }
3518
3519 hc_thread_mutex_unlock (mux_adl);
3520 }
3521
3522 if (restore_check == 1)
3523 {
3524 restore_left--;
3525
3526 if (restore_left == 0)
3527 {
3528 if (data.restore_disable == 0) cycle_restore ();
3529
3530 restore_left = data.restore_timer;
3531 }
3532 }
3533
3534 if ((runtime_check == 1) && (data.runtime_start > 0))
3535 {
3536 time_t runtime_cur;
3537
3538 time (&runtime_cur);
3539
3540 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3541
3542 if (runtime_left <= 0)
3543 {
3544 if (data.benchmark == 0)
3545 {
3546 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3547 }
3548
3549 if (data.devices_status != STATUS_QUIT) myabort ();
3550 }
3551 }
3552
3553 if (remove_check == 1)
3554 {
3555 remove_left--;
3556
3557 if (remove_left == 0)
3558 {
3559 if (data.digests_saved != data.digests_done)
3560 {
3561 data.digests_saved = data.digests_done;
3562
3563 save_hash ();
3564 }
3565
3566 remove_left = data.remove_timer;
3567 }
3568 }
3569
3570 if (status_check == 1)
3571 {
3572 status_left--;
3573
3574 if (status_left == 0)
3575 {
3576 hc_thread_mutex_lock (mux_display);
3577
3578 if (data.quiet == 0) clear_prompt ();
3579
3580 if (data.quiet == 0) log_info ("");
3581
3582 status_display ();
3583
3584 if (data.quiet == 0) log_info ("");
3585
3586 hc_thread_mutex_unlock (mux_display);
3587
3588 status_left = data.status_timer;
3589 }
3590 }
3591 }
3592
3593 myfree (fan_speed_chgd);
3594
3595 myfree (temp_diff_old);
3596 myfree (temp_diff_sum);
3597
3598 p = NULL;
3599
3600 return (p);
3601 }
3602
3603 static void *thread_outfile_remove (void *p)
3604 {
3605 // some hash-dependent constants
3606 char *outfile_dir = data.outfile_check_directory;
3607 uint dgst_size = data.dgst_size;
3608 uint isSalted = data.isSalted;
3609 uint esalt_size = data.esalt_size;
3610 uint hash_mode = data.hash_mode;
3611
3612 uint outfile_check_timer = data.outfile_check_timer;
3613
3614 char separator = data.separator;
3615
3616 // some hash-dependent functions
3617 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3618 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3619
3620 // buffers
3621 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3622
3623 hash_buf.digest = mymalloc (dgst_size);
3624
3625 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3626
3627 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3628
3629 uint digest_buf[64];
3630
3631 outfile_data_t *out_info = NULL;
3632
3633 char **out_files = NULL;
3634
3635 time_t folder_mtime = 0;
3636
3637 int out_cnt = 0;
3638
3639 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3640
3641 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3642 {
3643 hc_sleep (1);
3644
3645 if (data.devices_status != STATUS_RUNNING) continue;
3646
3647 check_left--;
3648
3649 if (check_left == 0)
3650 {
3651 struct stat outfile_check_stat;
3652
3653 if (stat (outfile_dir, &outfile_check_stat) == 0)
3654 {
3655 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3656
3657 if (is_dir == 1)
3658 {
3659 if (outfile_check_stat.st_mtime > folder_mtime)
3660 {
3661 char **out_files_new = scan_directory (outfile_dir);
3662
3663 int out_cnt_new = count_dictionaries (out_files_new);
3664
3665 outfile_data_t *out_info_new = NULL;
3666
3667 if (out_cnt_new > 0)
3668 {
3669 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3670
3671 for (int i = 0; i < out_cnt_new; i++)
3672 {
3673 out_info_new[i].file_name = out_files_new[i];
3674
3675 // check if there are files that we have seen/checked before (and not changed)
3676
3677 for (int j = 0; j < out_cnt; j++)
3678 {
3679 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3680 {
3681 struct stat outfile_stat;
3682
3683 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3684 {
3685 if (outfile_stat.st_ctime == out_info[j].ctime)
3686 {
3687 out_info_new[i].ctime = out_info[j].ctime;
3688 out_info_new[i].seek = out_info[j].seek;
3689 }
3690 }
3691 }
3692 }
3693 }
3694 }
3695
3696 local_free (out_info);
3697 local_free (out_files);
3698
3699 out_files = out_files_new;
3700 out_cnt = out_cnt_new;
3701 out_info = out_info_new;
3702
3703 folder_mtime = outfile_check_stat.st_mtime;
3704 }
3705
3706 for (int j = 0; j < out_cnt; j++)
3707 {
3708 FILE *fp = fopen (out_info[j].file_name, "rb");
3709
3710 if (fp != NULL)
3711 {
3712 //hc_thread_mutex_lock (mux_display);
3713
3714 #ifdef _POSIX
3715 struct stat outfile_stat;
3716
3717 fstat (fileno (fp), &outfile_stat);
3718 #endif
3719
3720 #ifdef _WIN
3721 struct stat64 outfile_stat;
3722
3723 _fstat64 (fileno (fp), &outfile_stat);
3724 #endif
3725
3726 if (outfile_stat.st_ctime > out_info[j].ctime)
3727 {
3728 out_info[j].ctime = outfile_stat.st_ctime;
3729 out_info[j].seek = 0;
3730 }
3731
3732 fseek (fp, out_info[j].seek, SEEK_SET);
3733
3734 while (!feof (fp))
3735 {
3736 char line_buf[BUFSIZ];
3737
3738 memset (line_buf, 0, BUFSIZ);
3739
3740 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3741
3742 if (ptr == NULL) break;
3743
3744 int line_len = strlen (line_buf);
3745
3746 if (line_len <= 0) continue;
3747
3748 int iter = MAX_CUT_TRIES;
3749
3750 for (uint i = line_len - 1; i && iter; i--, line_len--)
3751 {
3752 if (line_buf[i] != separator) continue;
3753
3754 int parser_status = PARSER_OK;
3755
3756 if ((hash_mode != 2500) && (hash_mode != 6800))
3757 {
3758 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3759 }
3760
3761 uint found = 0;
3762
3763 if (parser_status == PARSER_OK)
3764 {
3765 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3766 {
3767 if (data.salts_shown[salt_pos] == 1) continue;
3768
3769 salt_t *salt_buf = &data.salts_buf[salt_pos];
3770
3771 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3772 {
3773 uint idx = salt_buf->digests_offset + digest_pos;
3774
3775 if (data.digests_shown[idx] == 1) continue;
3776
3777 uint cracked = 0;
3778
3779 if (hash_mode == 6800)
3780 {
3781 if (i == salt_buf->salt_len)
3782 {
3783 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3784 }
3785 }
3786 else if (hash_mode == 2500)
3787 {
3788 // BSSID : MAC1 : MAC2 (:plain)
3789 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3790 {
3791 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3792
3793 if (!cracked) continue;
3794
3795 // now compare MAC1 and MAC2 too, since we have this additional info
3796 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3797 char *mac2_pos = mac1_pos + 12 + 1;
3798
3799 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3800 wpa_t *wpa = &wpas[salt_pos];
3801
3802 uint pke[25];
3803
3804 char *pke_ptr = (char *) pke;
3805
3806 for (uint i = 0; i < 25; i++)
3807 {
3808 pke[i] = byte_swap_32 (wpa->pke[i]);
3809 }
3810
3811 u8 mac1[6];
3812 u8 mac2[6];
3813
3814 memcpy (mac1, pke_ptr + 23, 6);
3815 memcpy (mac2, pke_ptr + 29, 6);
3816
3817 // compare hex string(s) vs binary MAC address(es)
3818
3819 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3820 {
3821 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3822 {
3823 cracked = 0;
3824 break;
3825 }
3826 }
3827
3828 // early skip ;)
3829 if (!cracked) continue;
3830
3831 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3832 {
3833 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3834 {
3835 cracked = 0;
3836 break;
3837 }
3838 }
3839 }
3840 }
3841 else
3842 {
3843 char *digests_buf_ptr = (char *) data.digests_buf;
3844
3845 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3846
3847 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3848 }
3849
3850 if (cracked == 1)
3851 {
3852 found = 1;
3853
3854 data.digests_shown[idx] = 1;
3855
3856 data.digests_done++;
3857
3858 salt_buf->digests_done++;
3859
3860 if (salt_buf->digests_done == salt_buf->digests_cnt)
3861 {
3862 data.salts_shown[salt_pos] = 1;
3863
3864 data.salts_done++;
3865
3866 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3867 }
3868 }
3869 }
3870
3871 if (data.devices_status == STATUS_CRACKED) break;
3872 }
3873 }
3874
3875 if (found) break;
3876
3877 if (data.devices_status == STATUS_CRACKED) break;
3878
3879 iter--;
3880 }
3881
3882 if (data.devices_status == STATUS_CRACKED) break;
3883 }
3884
3885 out_info[j].seek = ftell (fp);
3886
3887 //hc_thread_mutex_unlock (mux_display);
3888
3889 fclose (fp);
3890 }
3891 }
3892 }
3893 }
3894
3895 check_left = outfile_check_timer;
3896 }
3897 }
3898
3899 if (esalt_size) local_free (hash_buf.esalt);
3900
3901 if (isSalted) local_free (hash_buf.salt);
3902
3903 local_free (hash_buf.digest);
3904
3905 local_free (out_info);
3906
3907 local_free (out_files);
3908
3909 p = NULL;
3910
3911 return (p);
3912 }
3913
3914 static uint get_work (hc_device_param_t *device_param, const u64 max)
3915 {
3916 hc_thread_mutex_lock (mux_dispatcher);
3917
3918 const u64 words_cur = data.words_cur;
3919 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
3920
3921 device_param->words_off = words_cur;
3922
3923 const u64 words_left = words_base - words_cur;
3924
3925 if (data.kernel_blocks_all > words_left)
3926 {
3927 if (data.kernel_blocks_div == 0)
3928 {
3929 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3930 }
3931 }
3932
3933 if (data.kernel_blocks_div)
3934 {
3935 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3936 {
3937 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3938 const u32 kernel_power_new = kernel_blocks_new;
3939
3940 if (kernel_blocks_new < device_param->kernel_blocks)
3941 {
3942 device_param->kernel_blocks = kernel_blocks_new;
3943 device_param->kernel_power = kernel_power_new;
3944 }
3945 }
3946 }
3947
3948 const uint kernel_blocks = device_param->kernel_blocks;
3949
3950 uint work = MIN (words_left, kernel_blocks);
3951
3952 work = MIN (work, max);
3953
3954 data.words_cur += work;
3955
3956 hc_thread_mutex_unlock (mux_dispatcher);
3957
3958 return work;
3959 }
3960
3961 static void *thread_calc_stdin (void *p)
3962 {
3963 hc_device_param_t *device_param = (hc_device_param_t *) p;
3964
3965 if (device_param->skipped) return NULL;
3966
3967 const uint attack_kern = data.attack_kern;
3968
3969 const uint kernel_blocks = device_param->kernel_blocks;
3970
3971 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3972 {
3973 hc_thread_mutex_lock (mux_dispatcher);
3974
3975 if (feof (stdin) != 0)
3976 {
3977 hc_thread_mutex_unlock (mux_dispatcher);
3978
3979 break;
3980 }
3981
3982 uint words_cur = 0;
3983
3984 while (words_cur < kernel_blocks)
3985 {
3986 char buf[BUFSIZ];
3987
3988 char *line_buf = fgets (buf, sizeof (buf), stdin);
3989
3990 if (line_buf == NULL) break;
3991
3992 uint line_len = in_superchop (line_buf);
3993
3994 line_len = convert_from_hex (line_buf, line_len);
3995
3996 // post-process rule engine
3997
3998 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3999 {
4000 char rule_buf_out[BLOCK_SIZE] = { 0 };
4001
4002 int rule_len_out = -1;
4003
4004 if (line_len < BLOCK_SIZE)
4005 {
4006 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4007 }
4008
4009 if (rule_len_out < 0) continue;
4010
4011 line_buf = rule_buf_out;
4012 line_len = rule_len_out;
4013 }
4014
4015 if (line_len > PW_MAX)
4016 {
4017 continue;
4018 }
4019
4020 if (attack_kern == ATTACK_KERN_STRAIGHT)
4021 {
4022 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4023 {
4024 hc_thread_mutex_lock (mux_counter);
4025
4026 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4027 {
4028 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4029 }
4030
4031 hc_thread_mutex_unlock (mux_counter);
4032
4033 continue;
4034 }
4035 }
4036 else if (attack_kern == ATTACK_KERN_COMBI)
4037 {
4038 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4039 // since we still need to combine the plains
4040
4041 if (line_len > data.pw_max)
4042 {
4043 hc_thread_mutex_lock (mux_counter);
4044
4045 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4046 {
4047 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4048 }
4049
4050 hc_thread_mutex_unlock (mux_counter);
4051
4052 continue;
4053 }
4054 }
4055
4056 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4057
4058 words_cur++;
4059
4060 if (data.devices_status == STATUS_CRACKED) break;
4061 if (data.devices_status == STATUS_ABORTED) break;
4062 if (data.devices_status == STATUS_QUIT) break;
4063 if (data.devices_status == STATUS_BYPASS) break;
4064 }
4065
4066 hc_thread_mutex_unlock (mux_dispatcher);
4067
4068 if (data.devices_status == STATUS_CRACKED) break;
4069 if (data.devices_status == STATUS_ABORTED) break;
4070 if (data.devices_status == STATUS_QUIT) break;
4071 if (data.devices_status == STATUS_BYPASS) break;
4072
4073 // we need 2 flushing because we have two independant caches and it can occur
4074 // that one buffer is already at threshold plus for that length also exists
4075 // more data in the 2nd buffer so it would overflow
4076
4077 // flush session 1
4078
4079 {
4080 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4081 {
4082 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4083
4084 const uint pw_cache_cnt = pw_cache->cnt;
4085
4086 if (pw_cache_cnt == 0) continue;
4087
4088 pw_cache->cnt = 0;
4089
4090 uint pws_cnt = device_param->pws_cnt;
4091
4092 pw_t *pw = device_param->pws_buf + pws_cnt;
4093
4094 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4095
4096 pw->pw_len = pw_len;
4097
4098 uint pw_cnt = device_param->pw_cnt;
4099
4100 pw_cnt += pw_cache_cnt;
4101
4102 device_param->pw_cnt = pw_cnt;
4103
4104 pws_cnt++;
4105
4106 device_param->pws_cnt = pws_cnt;
4107
4108 if (pws_cnt == device_param->kernel_power_user) break;
4109 }
4110
4111 const uint pw_cnt = device_param->pw_cnt;
4112 const uint pws_cnt = device_param->pws_cnt;
4113
4114 if (pws_cnt)
4115 {
4116 run_copy (device_param, pws_cnt);
4117
4118 run_cracker (device_param, pw_cnt, pws_cnt);
4119
4120 device_param->pw_cnt = 0;
4121 device_param->pws_cnt = 0;
4122 }
4123 }
4124
4125 // flush session 2
4126
4127 {
4128 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4129 {
4130 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4131
4132 const uint pw_cache_cnt = pw_cache->cnt;
4133
4134 if (pw_cache_cnt == 0) continue;
4135
4136 pw_cache->cnt = 0;
4137
4138 uint pws_cnt = device_param->pws_cnt;
4139
4140 pw_t *pw = device_param->pws_buf + pws_cnt;
4141
4142 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4143
4144 pw->pw_len = pw_len;
4145
4146 uint pw_cnt = device_param->pw_cnt;
4147
4148 pw_cnt += pw_cache_cnt;
4149
4150 device_param->pw_cnt = pw_cnt;
4151
4152 pws_cnt++;
4153
4154 device_param->pws_cnt = pws_cnt;
4155 }
4156
4157 const uint pw_cnt = device_param->pw_cnt;
4158 const uint pws_cnt = device_param->pws_cnt;
4159
4160 if (pws_cnt)
4161 {
4162 run_copy (device_param, pws_cnt);
4163
4164 run_cracker (device_param, pw_cnt, pws_cnt);
4165
4166 device_param->pw_cnt = 0;
4167 device_param->pws_cnt = 0;
4168 }
4169 }
4170 }
4171
4172 return NULL;
4173 }
4174
4175 static void *thread_calc (void *p)
4176 {
4177 hc_device_param_t *device_param = (hc_device_param_t *) p;
4178
4179 if (device_param->skipped) return NULL;
4180
4181 const uint attack_mode = data.attack_mode;
4182 const uint attack_kern = data.attack_kern;
4183
4184 if (attack_mode == ATTACK_MODE_BF)
4185 {
4186 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4187 {
4188 const uint work = get_work (device_param, -1);
4189
4190 if (work == 0) break;
4191
4192 const u64 words_off = device_param->words_off;
4193 const u64 words_fin = words_off + work;
4194
4195 const uint pw_cnt = work;
4196 const uint pws_cnt = work;
4197
4198 device_param->pw_cnt = pw_cnt;
4199 device_param->pws_cnt = pws_cnt;
4200
4201 if (pws_cnt)
4202 {
4203 run_copy (device_param, pws_cnt);
4204
4205 run_cracker (device_param, pw_cnt, pws_cnt);
4206
4207 device_param->pw_cnt = 0;
4208 device_param->pws_cnt = 0;
4209 }
4210
4211 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4212
4213 if (data.devices_status == STATUS_CRACKED) break;
4214 if (data.devices_status == STATUS_ABORTED) break;
4215 if (data.devices_status == STATUS_QUIT) break;
4216 if (data.devices_status == STATUS_BYPASS) break;
4217
4218 device_param->words_done = words_fin;
4219 }
4220 }
4221 else
4222 {
4223 const uint segment_size = data.segment_size;
4224
4225 char *dictfile = data.dictfile;
4226
4227 if (attack_mode == ATTACK_MODE_COMBI)
4228 {
4229 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4230 {
4231 dictfile = data.dictfile2;
4232 }
4233 }
4234
4235 FILE *fd = fopen (dictfile, "rb");
4236
4237 if (fd == NULL)
4238 {
4239 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4240
4241 return NULL;
4242 }
4243
4244 if (attack_mode == ATTACK_MODE_COMBI)
4245 {
4246 const uint combs_mode = data.combs_mode;
4247
4248 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4249 {
4250 const char *dictfilec = data.dictfile2;
4251
4252 FILE *combs_fp = fopen (dictfilec, "rb");
4253
4254 if (combs_fp == NULL)
4255 {
4256 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4257
4258 fclose (fd);
4259
4260 return NULL;
4261 }
4262
4263 device_param->combs_fp = combs_fp;
4264 }
4265 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4266 {
4267 const char *dictfilec = data.dictfile;
4268
4269 FILE *combs_fp = fopen (dictfilec, "rb");
4270
4271 if (combs_fp == NULL)
4272 {
4273 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4274
4275 fclose (fd);
4276
4277 return NULL;
4278 }
4279
4280 device_param->combs_fp = combs_fp;
4281 }
4282 }
4283
4284 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4285
4286 wl_data->buf = (char *) mymalloc (segment_size);
4287 wl_data->avail = segment_size;
4288 wl_data->incr = segment_size;
4289 wl_data->cnt = 0;
4290 wl_data->pos = 0;
4291
4292 u64 words_cur = 0;
4293
4294 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4295 {
4296 u64 words_off = 0;
4297 u64 words_fin = 0;
4298
4299 u64 max = -1;
4300
4301 while (max)
4302 {
4303 const uint work = get_work (device_param, max);
4304
4305 if (work == 0) break;
4306
4307 words_off = device_param->words_off;
4308 words_fin = words_off + work;
4309
4310 char *line_buf;
4311 uint line_len;
4312
4313 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4314
4315 max = 0;
4316
4317 for ( ; words_cur < words_fin; words_cur++)
4318 {
4319 get_next_word (wl_data, fd, &line_buf, &line_len);
4320
4321 line_len = convert_from_hex (line_buf, line_len);
4322
4323 // post-process rule engine
4324
4325 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4326 {
4327 char rule_buf_out[BLOCK_SIZE] = { 0 };
4328
4329 int rule_len_out = -1;
4330
4331 if (line_len < BLOCK_SIZE)
4332 {
4333 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4334 }
4335
4336 if (rule_len_out < 0) continue;
4337
4338 line_buf = rule_buf_out;
4339 line_len = rule_len_out;
4340 }
4341
4342 if (attack_kern == ATTACK_KERN_STRAIGHT)
4343 {
4344 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4345 {
4346 max++;
4347
4348 hc_thread_mutex_lock (mux_counter);
4349
4350 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4351 {
4352 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4353 }
4354
4355 hc_thread_mutex_unlock (mux_counter);
4356
4357 continue;
4358 }
4359 }
4360 else if (attack_kern == ATTACK_KERN_COMBI)
4361 {
4362 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4363 // since we still need to combine the plains
4364
4365 if (line_len > data.pw_max)
4366 {
4367 max++;
4368
4369 hc_thread_mutex_lock (mux_counter);
4370
4371 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4372 {
4373 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4374 }
4375
4376 hc_thread_mutex_unlock (mux_counter);
4377
4378 continue;
4379 }
4380 }
4381
4382 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4383
4384 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4385
4386 if (data.devices_status == STATUS_CRACKED) break;
4387 if (data.devices_status == STATUS_ABORTED) break;
4388 if (data.devices_status == STATUS_QUIT) break;
4389 if (data.devices_status == STATUS_BYPASS) break;
4390 }
4391
4392 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4393
4394 if (data.devices_status == STATUS_CRACKED) break;
4395 if (data.devices_status == STATUS_ABORTED) break;
4396 if (data.devices_status == STATUS_QUIT) break;
4397 if (data.devices_status == STATUS_BYPASS) break;
4398 }
4399
4400 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4401
4402 if (data.devices_status == STATUS_CRACKED) break;
4403 if (data.devices_status == STATUS_ABORTED) break;
4404 if (data.devices_status == STATUS_QUIT) break;
4405 if (data.devices_status == STATUS_BYPASS) break;
4406
4407 // we need 2 flushing because we have two independant caches and it can occur
4408 // that one buffer is already at threshold plus for that length also exists
4409 // more data in the 2nd buffer so it would overflow
4410
4411 //
4412 // flush session 1
4413 //
4414
4415 {
4416 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4417 {
4418 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4419
4420 const uint pw_cache_cnt = pw_cache->cnt;
4421
4422 if (pw_cache_cnt == 0) continue;
4423
4424 pw_cache->cnt = 0;
4425
4426 uint pws_cnt = device_param->pws_cnt;
4427
4428 pw_t *pw = device_param->pws_buf + pws_cnt;
4429
4430 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4431
4432 pw->pw_len = pw_len;
4433
4434 uint pw_cnt = device_param->pw_cnt;
4435
4436 pw_cnt += pw_cache_cnt;
4437
4438 device_param->pw_cnt = pw_cnt;
4439
4440 pws_cnt++;
4441
4442 device_param->pws_cnt = pws_cnt;
4443
4444 if (pws_cnt == device_param->kernel_power_user) break;
4445 }
4446
4447 const uint pw_cnt = device_param->pw_cnt;
4448 const uint pws_cnt = device_param->pws_cnt;
4449
4450 if (pws_cnt)
4451 {
4452 run_copy (device_param, pws_cnt);
4453
4454 run_cracker (device_param, pw_cnt, pws_cnt);
4455
4456 device_param->pw_cnt = 0;
4457 device_param->pws_cnt = 0;
4458 }
4459
4460 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4461
4462 if (data.devices_status == STATUS_CRACKED) break;
4463 if (data.devices_status == STATUS_ABORTED) break;
4464 if (data.devices_status == STATUS_QUIT) break;
4465 if (data.devices_status == STATUS_BYPASS) break;
4466 }
4467
4468 //
4469 // flush session 2
4470 //
4471
4472 {
4473 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4474 {
4475 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4476
4477 const uint pw_cache_cnt = pw_cache->cnt;
4478
4479 if (pw_cache_cnt == 0) continue;
4480
4481 pw_cache->cnt = 0;
4482
4483 uint pws_cnt = device_param->pws_cnt;
4484
4485 pw_t *pw = device_param->pws_buf + pws_cnt;
4486
4487 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4488
4489 pw->pw_len = pw_len;
4490
4491 uint pw_cnt = device_param->pw_cnt;
4492
4493 pw_cnt += pw_cache_cnt;
4494
4495 device_param->pw_cnt = pw_cnt;
4496
4497 pws_cnt++;
4498
4499 device_param->pws_cnt = pws_cnt;
4500 }
4501
4502 const uint pw_cnt = device_param->pw_cnt;
4503 const uint pws_cnt = device_param->pws_cnt;
4504
4505 if (pws_cnt)
4506 {
4507 run_copy (device_param, pws_cnt);
4508
4509 run_cracker (device_param, pw_cnt, pws_cnt);
4510
4511 device_param->pw_cnt = 0;
4512 device_param->pws_cnt = 0;
4513 }
4514
4515 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4516
4517 if (data.devices_status == STATUS_CRACKED) break;
4518 if (data.devices_status == STATUS_ABORTED) break;
4519 if (data.devices_status == STATUS_QUIT) break;
4520 if (data.devices_status == STATUS_BYPASS) break;
4521 }
4522
4523 if (words_fin == 0) break;
4524
4525 device_param->words_done = words_fin;
4526 }
4527
4528 if (attack_mode == ATTACK_MODE_COMBI)
4529 {
4530 fclose (device_param->combs_fp);
4531 }
4532
4533 free (wl_data->buf);
4534 free (wl_data);
4535
4536 fclose (fd);
4537 }
4538
4539 return NULL;
4540 }
4541
4542 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4543 {
4544 salt_t *salt_buf = &data.salts_buf[salt_pos];
4545
4546 device_param->kernel_params_buf32[24] = salt_pos;
4547 device_param->kernel_params_buf32[27] = 1;
4548 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4549 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4550 device_param->kernel_params_buf32[30] = 0;
4551 device_param->kernel_params_buf32[31] = 1;
4552
4553 char *dictfile_old = data.dictfile;
4554
4555 const char *weak_hash_check = "weak-hash-check";
4556
4557 data.dictfile = (char *) weak_hash_check;
4558
4559 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4560
4561 data.kernel_rules_buf[0].cmds[0] = 0;
4562
4563 /**
4564 * run the kernel
4565 */
4566
4567 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4568 {
4569 run_kernel (KERN_RUN_1, device_param, 1);
4570 }
4571 else
4572 {
4573 run_kernel (KERN_RUN_1, device_param, 1);
4574
4575 const uint iter = salt_buf->salt_iter;
4576
4577 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4578 {
4579 uint loop_left = iter - loop_pos;
4580
4581 loop_left = MIN (loop_left, kernel_loops);
4582
4583 device_param->kernel_params_buf32[25] = loop_pos;
4584 device_param->kernel_params_buf32[26] = loop_left;
4585
4586 run_kernel (KERN_RUN_2, device_param, 1);
4587 }
4588
4589 run_kernel (KERN_RUN_3, device_param, 1);
4590 }
4591
4592 /**
4593 * result
4594 */
4595
4596 check_cracked (device_param, salt_pos);
4597
4598 /**
4599 * cleanup
4600 */
4601
4602 device_param->kernel_params_buf32[24] = 0;
4603 device_param->kernel_params_buf32[25] = 0;
4604 device_param->kernel_params_buf32[26] = 0;
4605 device_param->kernel_params_buf32[27] = 0;
4606 device_param->kernel_params_buf32[28] = 0;
4607 device_param->kernel_params_buf32[29] = 0;
4608 device_param->kernel_params_buf32[30] = 0;
4609 device_param->kernel_params_buf32[31] = 0;
4610
4611 data.dictfile = dictfile_old;
4612
4613 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4614 }
4615
4616 // hlfmt hashcat
4617
4618 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4619 {
4620 if (data.username == 0)
4621 {
4622 *hashbuf_pos = line_buf;
4623 *hashbuf_len = line_len;
4624 }
4625 else
4626 {
4627 char *pos = line_buf;
4628 int len = line_len;
4629
4630 for (int i = 0; i < line_len; i++, pos++, len--)
4631 {
4632 if (line_buf[i] == data.separator)
4633 {
4634 pos++;
4635
4636 len--;
4637
4638 break;
4639 }
4640 }
4641
4642 *hashbuf_pos = pos;
4643 *hashbuf_len = len;
4644 }
4645 }
4646
4647 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4648 {
4649 char *pos = NULL;
4650 int len = 0;
4651
4652 int sep_cnt = 0;
4653
4654 for (int i = 0; i < line_len; i++)
4655 {
4656 if (line_buf[i] == data.separator)
4657 {
4658 sep_cnt++;
4659
4660 continue;
4661 }
4662
4663 if (sep_cnt == 0)
4664 {
4665 if (pos == NULL) pos = line_buf + i;
4666
4667 len++;
4668 }
4669 }
4670
4671 *userbuf_pos = pos;
4672 *userbuf_len = len;
4673 }
4674
4675 // hlfmt pwdump
4676
4677 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4678 {
4679 int sep_cnt = 0;
4680
4681 int sep2_len = 0;
4682 int sep3_len = 0;
4683
4684 for (int i = 0; i < line_len; i++)
4685 {
4686 if (line_buf[i] == ':')
4687 {
4688 sep_cnt++;
4689
4690 continue;
4691 }
4692
4693 if (sep_cnt == 2) sep2_len++;
4694 if (sep_cnt == 3) sep3_len++;
4695 }
4696
4697 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4698
4699 return 0;
4700 }
4701
4702 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4703 {
4704 char *pos = NULL;
4705 int len = 0;
4706
4707 int sep_cnt = 0;
4708
4709 for (int i = 0; i < line_len; i++)
4710 {
4711 if (line_buf[i] == ':')
4712 {
4713 sep_cnt++;
4714
4715 continue;
4716 }
4717
4718 if (data.hash_mode == 1000)
4719 {
4720 if (sep_cnt == 3)
4721 {
4722 if (pos == NULL) pos = line_buf + i;
4723
4724 len++;
4725 }
4726 }
4727 else if (data.hash_mode == 3000)
4728 {
4729 if (sep_cnt == 2)
4730 {
4731 if (pos == NULL) pos = line_buf + i;
4732
4733 len++;
4734 }
4735 }
4736 }
4737
4738 *hashbuf_pos = pos;
4739 *hashbuf_len = len;
4740 }
4741
4742 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4743 {
4744 char *pos = NULL;
4745 int len = 0;
4746
4747 int sep_cnt = 0;
4748
4749 for (int i = 0; i < line_len; i++)
4750 {
4751 if (line_buf[i] == ':')
4752 {
4753 sep_cnt++;
4754
4755 continue;
4756 }
4757
4758 if (sep_cnt == 0)
4759 {
4760 if (pos == NULL) pos = line_buf + i;
4761
4762 len++;
4763 }
4764 }
4765
4766 *userbuf_pos = pos;
4767 *userbuf_len = len;
4768 }
4769
4770 // hlfmt passwd
4771
4772 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4773 {
4774 int sep_cnt = 0;
4775
4776 char sep5_first = 0;
4777 char sep6_first = 0;
4778
4779 for (int i = 0; i < line_len; i++)
4780 {
4781 if (line_buf[i] == ':')
4782 {
4783 sep_cnt++;
4784
4785 continue;
4786 }
4787
4788 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4789 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4790 }
4791
4792 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4793
4794 return 0;
4795 }
4796
4797 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4798 {
4799 char *pos = NULL;
4800 int len = 0;
4801
4802 int sep_cnt = 0;
4803
4804 for (int i = 0; i < line_len; i++)
4805 {
4806 if (line_buf[i] == ':')
4807 {
4808 sep_cnt++;
4809
4810 continue;
4811 }
4812
4813 if (sep_cnt == 1)
4814 {
4815 if (pos == NULL) pos = line_buf + i;
4816
4817 len++;
4818 }
4819 }
4820
4821 *hashbuf_pos = pos;
4822 *hashbuf_len = len;
4823 }
4824
4825 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4826 {
4827 char *pos = NULL;
4828 int len = 0;
4829
4830 int sep_cnt = 0;
4831
4832 for (int i = 0; i < line_len; i++)
4833 {
4834 if (line_buf[i] == ':')
4835 {
4836 sep_cnt++;
4837
4838 continue;
4839 }
4840
4841 if (sep_cnt == 0)
4842 {
4843 if (pos == NULL) pos = line_buf + i;
4844
4845 len++;
4846 }
4847 }
4848
4849 *userbuf_pos = pos;
4850 *userbuf_len = len;
4851 }
4852
4853 // hlfmt shadow
4854
4855 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4856 {
4857 int sep_cnt = 0;
4858
4859 for (int i = 0; i < line_len; i++)
4860 {
4861 if (line_buf[i] == ':') sep_cnt++;
4862 }
4863
4864 if (sep_cnt == 8) return 1;
4865
4866 return 0;
4867 }
4868
4869 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4870 {
4871 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4872 }
4873
4874 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4875 {
4876 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4877 }
4878
4879 // hlfmt main
4880
4881 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4882 {
4883 switch (hashfile_format)
4884 {
4885 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4886 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4887 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4888 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4889 }
4890 }
4891
4892 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4893 {
4894 switch (hashfile_format)
4895 {
4896 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4897 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4898 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4899 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4900 }
4901 }
4902
4903 static uint hlfmt_detect (FILE *fp, uint max_check)
4904 {
4905 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4906
4907 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4908 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4909
4910 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4911
4912 uint num_check = 0;
4913
4914 while (!feof (fp))
4915 {
4916 char line_buf[BUFSIZ];
4917
4918 int line_len = fgetl (fp, line_buf);
4919
4920 if (line_len == 0) continue;
4921
4922 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4923 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4924 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4925
4926 if (num_check == max_check) break;
4927
4928 num_check++;
4929 }
4930
4931 uint hashlist_format = HLFMT_HASHCAT;
4932
4933 for (int i = 1; i < HLFMTS_CNT; i++)
4934 {
4935 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4936
4937 hashlist_format = i;
4938 }
4939
4940 free (formats_cnt);
4941
4942 return hashlist_format;
4943 }
4944
4945 /**
4946 * some further helper function
4947 */
4948
4949 // wrapper around mymalloc for ADL
4950
4951 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4952 {
4953 return mymalloc (iSize);
4954 }
4955
4956 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
4957 {
4958 u64 collisions = 0;
4959
4960 const uint dgst_pos0 = data.dgst_pos0;
4961 const uint dgst_pos1 = data.dgst_pos1;
4962 const uint dgst_pos2 = data.dgst_pos2;
4963 const uint dgst_pos3 = data.dgst_pos3;
4964
4965 memset (bitmap_a, 0, bitmap_size);
4966 memset (bitmap_b, 0, bitmap_size);
4967 memset (bitmap_c, 0, bitmap_size);
4968 memset (bitmap_d, 0, bitmap_size);
4969
4970 for (uint i = 0; i < digests_cnt; i++)
4971 {
4972 uint *digest_ptr = (uint *) digests_buf_ptr;
4973
4974 digests_buf_ptr += dgst_size;
4975
4976 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
4977 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
4978 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
4979 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
4980
4981 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4982 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4983 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4984 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4985
4986 if (bitmap_a[idx0] & val0) collisions++;
4987 if (bitmap_b[idx1] & val1) collisions++;
4988 if (bitmap_c[idx2] & val2) collisions++;
4989 if (bitmap_d[idx3] & val3) collisions++;
4990
4991 bitmap_a[idx0] |= val0;
4992 bitmap_b[idx1] |= val1;
4993 bitmap_c[idx2] |= val2;
4994 bitmap_d[idx3] |= val3;
4995
4996 if (collisions >= collisions_max) return 0x7fffffff;
4997 }
4998
4999 return collisions;
5000 }
5001
5002 /**
5003 * main
5004 */
5005
5006 int main (int argc, char **argv)
5007 {
5008 /**
5009 * To help users a bit
5010 */
5011
5012 char *compute = getenv ("COMPUTE");
5013
5014 if (compute)
5015 {
5016 char display[100];
5017
5018 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5019
5020 putenv (display);
5021 }
5022 else
5023 {
5024 if (getenv ("DISPLAY") == NULL)
5025 putenv ((char *) "DISPLAY=:0");
5026 }
5027
5028 /*
5029 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5030 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5031
5032 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5033 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5034 */
5035
5036 /**
5037 * Real init
5038 */
5039
5040 memset (&data, 0, sizeof (hc_global_data_t));
5041
5042 time_t proc_start;
5043
5044 time (&proc_start);
5045
5046 data.proc_start = proc_start;
5047
5048 int myargc = argc;
5049 char **myargv = argv;
5050
5051 hc_thread_mutex_init (mux_dispatcher);
5052 hc_thread_mutex_init (mux_counter);
5053 hc_thread_mutex_init (mux_display);
5054 hc_thread_mutex_init (mux_adl);
5055
5056 /**
5057 * commandline parameters
5058 */
5059
5060 uint usage = USAGE;
5061 uint version = VERSION;
5062 uint quiet = QUIET;
5063 uint benchmark = BENCHMARK;
5064 uint benchmark_mode = BENCHMARK_MODE;
5065 uint show = SHOW;
5066 uint left = LEFT;
5067 uint username = USERNAME;
5068 uint remove = REMOVE;
5069 uint remove_timer = REMOVE_TIMER;
5070 u64 skip = SKIP;
5071 u64 limit = LIMIT;
5072 uint keyspace = KEYSPACE;
5073 uint potfile_disable = POTFILE_DISABLE;
5074 uint debug_mode = DEBUG_MODE;
5075 char *debug_file = NULL;
5076 char *induction_dir = NULL;
5077 char *outfile_check_dir = NULL;
5078 uint force = FORCE;
5079 uint runtime = RUNTIME;
5080 uint hash_mode = HASH_MODE;
5081 uint attack_mode = ATTACK_MODE;
5082 uint markov_disable = MARKOV_DISABLE;
5083 uint markov_classic = MARKOV_CLASSIC;
5084 uint markov_threshold = MARKOV_THRESHOLD;
5085 char *markov_hcstat = NULL;
5086 char *outfile = NULL;
5087 uint outfile_format = OUTFILE_FORMAT;
5088 uint outfile_autohex = OUTFILE_AUTOHEX;
5089 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5090 uint restore = RESTORE;
5091 uint restore_timer = RESTORE_TIMER;
5092 uint restore_disable = RESTORE_DISABLE;
5093 uint status = STATUS;
5094 uint status_timer = STATUS_TIMER;
5095 uint status_automat = STATUS_AUTOMAT;
5096 uint loopback = LOOPBACK;
5097 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5098 char *session = NULL;
5099 uint hex_charset = HEX_CHARSET;
5100 uint hex_salt = HEX_SALT;
5101 uint hex_wordlist = HEX_WORDLIST;
5102 uint rp_gen = RP_GEN;
5103 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5104 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5105 uint rp_gen_seed = RP_GEN_SEED;
5106 char *rule_buf_l = (char *) RULE_BUF_L;
5107 char *rule_buf_r = (char *) RULE_BUF_R;
5108 uint increment = INCREMENT;
5109 uint increment_min = INCREMENT_MIN;
5110 uint increment_max = INCREMENT_MAX;
5111 char *cpu_affinity = NULL;
5112 char *opencl_devices = NULL;
5113 char *opencl_platforms = NULL;
5114 char *opencl_device_types = NULL;
5115 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5116 char *truecrypt_keyfiles = NULL;
5117 uint workload_profile = WORKLOAD_PROFILE;
5118 uint kernel_accel = KERNEL_ACCEL;
5119 uint kernel_loops = KERNEL_LOOPS;
5120 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5121 uint gpu_temp_abort = GPU_TEMP_ABORT;
5122 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5123 uint powertune_enable = POWERTUNE_ENABLE;
5124 uint logfile_disable = LOGFILE_DISABLE;
5125 uint segment_size = SEGMENT_SIZE;
5126 uint scrypt_tmto = SCRYPT_TMTO;
5127 char separator = SEPARATOR;
5128 uint bitmap_min = BITMAP_MIN;
5129 uint bitmap_max = BITMAP_MAX;
5130 char *custom_charset_1 = NULL;
5131 char *custom_charset_2 = NULL;
5132 char *custom_charset_3 = NULL;
5133 char *custom_charset_4 = NULL;
5134
5135 #define IDX_HELP 'h'
5136 #define IDX_VERSION 'V'
5137 #define IDX_VERSION_LOWER 'v'
5138 #define IDX_QUIET 0xff02
5139 #define IDX_SHOW 0xff03
5140 #define IDX_LEFT 0xff04
5141 #define IDX_REMOVE 0xff05
5142 #define IDX_REMOVE_TIMER 0xff37
5143 #define IDX_SKIP 's'
5144 #define IDX_LIMIT 'l'
5145 #define IDX_KEYSPACE 0xff35
5146 #define IDX_POTFILE_DISABLE 0xff06
5147 #define IDX_DEBUG_MODE 0xff43
5148 #define IDX_DEBUG_FILE 0xff44
5149 #define IDX_INDUCTION_DIR 0xff46
5150 #define IDX_OUTFILE_CHECK_DIR 0xff47
5151 #define IDX_USERNAME 0xff07
5152 #define IDX_FORCE 0xff08
5153 #define IDX_RUNTIME 0xff09
5154 #define IDX_BENCHMARK 'b'
5155 #define IDX_BENCHMARK_MODE 0xff32
5156 #define IDX_HASH_MODE 'm'
5157 #define IDX_ATTACK_MODE 'a'
5158 #define IDX_RP_FILE 'r'
5159 #define IDX_RP_GEN 'g'
5160 #define IDX_RP_GEN_FUNC_MIN 0xff10
5161 #define IDX_RP_GEN_FUNC_MAX 0xff11
5162 #define IDX_RP_GEN_SEED 0xff34
5163 #define IDX_RULE_BUF_L 'j'
5164 #define IDX_RULE_BUF_R 'k'
5165 #define IDX_INCREMENT 'i'
5166 #define IDX_INCREMENT_MIN 0xff12
5167 #define IDX_INCREMENT_MAX 0xff13
5168 #define IDX_OUTFILE 'o'
5169 #define IDX_OUTFILE_FORMAT 0xff14
5170 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5171 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5172 #define IDX_RESTORE 0xff15
5173 #define IDX_RESTORE_DISABLE 0xff27
5174 #define IDX_STATUS 0xff17
5175 #define IDX_STATUS_TIMER 0xff18
5176 #define IDX_STATUS_AUTOMAT 0xff50
5177 #define IDX_LOOPBACK 0xff38
5178 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5179 #define IDX_SESSION 0xff19
5180 #define IDX_HEX_CHARSET 0xff20
5181 #define IDX_HEX_SALT 0xff21
5182 #define IDX_HEX_WORDLIST 0xff40
5183 #define IDX_MARKOV_DISABLE 0xff22
5184 #define IDX_MARKOV_CLASSIC 0xff23
5185 #define IDX_MARKOV_THRESHOLD 't'
5186 #define IDX_MARKOV_HCSTAT 0xff24
5187 #define IDX_CPU_AFFINITY 0xff25
5188 #define IDX_OPENCL_DEVICES 'd'
5189 #define IDX_OPENCL_PLATFORMS 0xff72
5190 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5191 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5192 #define IDX_WORKLOAD_PROFILE 'w'
5193 #define IDX_KERNEL_ACCEL 'n'
5194 #define IDX_KERNEL_LOOPS 'u'
5195 #define IDX_GPU_TEMP_DISABLE 0xff29
5196 #define IDX_GPU_TEMP_ABORT 0xff30
5197 #define IDX_GPU_TEMP_RETAIN 0xff31
5198 #define IDX_POWERTUNE_ENABLE 0xff41
5199 #define IDX_LOGFILE_DISABLE 0xff51
5200 #define IDX_TRUECRYPT_KEYFILES 0xff52
5201 #define IDX_SCRYPT_TMTO 0xff61
5202 #define IDX_SEGMENT_SIZE 'c'
5203 #define IDX_SEPARATOR 'p'
5204 #define IDX_BITMAP_MIN 0xff70
5205 #define IDX_BITMAP_MAX 0xff71
5206 #define IDX_CUSTOM_CHARSET_1 '1'
5207 #define IDX_CUSTOM_CHARSET_2 '2'
5208 #define IDX_CUSTOM_CHARSET_3 '3'
5209 #define IDX_CUSTOM_CHARSET_4 '4'
5210
5211 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5212
5213 struct option long_options[] =
5214 {
5215 {"help", no_argument, 0, IDX_HELP},
5216 {"version", no_argument, 0, IDX_VERSION},
5217 {"quiet", no_argument, 0, IDX_QUIET},
5218 {"show", no_argument, 0, IDX_SHOW},
5219 {"left", no_argument, 0, IDX_LEFT},
5220 {"username", no_argument, 0, IDX_USERNAME},
5221 {"remove", no_argument, 0, IDX_REMOVE},
5222 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5223 {"skip", required_argument, 0, IDX_SKIP},
5224 {"limit", required_argument, 0, IDX_LIMIT},
5225 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5226 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5227 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5228 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5229 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5230 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5231 {"force", no_argument, 0, IDX_FORCE},
5232 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5233 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5234 {"restore", no_argument, 0, IDX_RESTORE},
5235 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5236 {"status", no_argument, 0, IDX_STATUS},
5237 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5238 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5239 {"loopback", no_argument, 0, IDX_LOOPBACK},
5240 {"weak-hash-threshold",
5241 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5242 {"session", required_argument, 0, IDX_SESSION},
5243 {"runtime", required_argument, 0, IDX_RUNTIME},
5244 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5245 {"generate-rules-func-min",
5246 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5247 {"generate-rules-func-max",
5248 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5249 {"generate-rules-seed",
5250 required_argument, 0, IDX_RP_GEN_SEED},
5251 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5252 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5253 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5254 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5255 {"rules-file", required_argument, 0, IDX_RP_FILE},
5256 {"outfile", required_argument, 0, IDX_OUTFILE},
5257 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5258 {"outfile-autohex-disable",
5259 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5260 {"outfile-check-timer",
5261 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5262 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5263 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5264 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5265 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5266 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5267 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5268 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5269 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5270 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5271 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5272 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5273 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5274 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5275 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5276 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5277 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5278 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5279 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5280 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5281 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5282 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5283 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5284 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5285 // deprecated
5286 {"seperator", required_argument, 0, IDX_SEPARATOR},
5287 {"separator", required_argument, 0, IDX_SEPARATOR},
5288 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5289 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5290 {"increment", no_argument, 0, IDX_INCREMENT},
5291 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5292 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5293 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5294 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5295 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5296 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5297
5298 {0, 0, 0, 0}
5299 };
5300
5301 uint rp_files_cnt = 0;
5302
5303 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5304
5305 int option_index;
5306 int c;
5307
5308 optind = 1;
5309 optopt = 0;
5310 option_index = 0;
5311
5312 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5313 {
5314 switch (c)
5315 {
5316 case IDX_HELP: usage = 1; break;
5317 case IDX_VERSION:
5318 case IDX_VERSION_LOWER: version = 1; break;
5319 case IDX_RESTORE: restore = 1; break;
5320 case IDX_SESSION: session = optarg; break;
5321 case IDX_SHOW: show = 1; break;
5322 case IDX_LEFT: left = 1; break;
5323 case '?': return (-1);
5324 }
5325 }
5326
5327 if (optopt != 0)
5328 {
5329 log_error ("ERROR: Invalid argument specified");
5330
5331 return (-1);
5332 }
5333
5334 /**
5335 * exit functions
5336 */
5337
5338 if (version)
5339 {
5340 log_info (VERSION_TXT);
5341
5342 return (0);
5343 }
5344
5345 if (usage)
5346 {
5347 usage_big_print (PROGNAME);
5348
5349 return (0);
5350 }
5351
5352 /**
5353 * session needs to be set, always!
5354 */
5355
5356 if (session == NULL) session = (char *) PROGNAME;
5357
5358 /**
5359 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5360 */
5361
5362 char *exec_path = get_exec_path ();
5363
5364 #ifdef LINUX
5365
5366 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5367 char *resolved_exec_path = realpath (exec_path, NULL);
5368
5369 char *install_dir = get_install_dir (resolved_exec_path);
5370 char *profile_dir = NULL;
5371 char *session_dir = NULL;
5372 char *shared_dir = NULL;
5373
5374 if (strcmp (install_dir, resolved_install_folder) == 0)
5375 {
5376 struct passwd *pw = getpwuid (getuid ());
5377
5378 const char *homedir = pw->pw_dir;
5379
5380 profile_dir = get_profile_dir (homedir);
5381 session_dir = get_session_dir (profile_dir);
5382 shared_dir = strdup (SHARED_FOLDER);
5383
5384 mkdir (profile_dir, 0700);
5385 mkdir (session_dir, 0700);
5386 }
5387 else
5388 {
5389 profile_dir = install_dir;
5390 session_dir = install_dir;
5391 shared_dir = install_dir;
5392 }
5393
5394 myfree (resolved_install_folder);
5395 myfree (resolved_exec_path);
5396
5397 #else
5398
5399 char *install_dir = get_install_dir (exec_path);
5400 char *profile_dir = install_dir;
5401 char *session_dir = install_dir;
5402 char *shared_dir = install_dir;
5403
5404 #endif
5405
5406 data.install_dir = install_dir;
5407 data.profile_dir = profile_dir;
5408 data.session_dir = session_dir;
5409 data.shared_dir = shared_dir;
5410
5411 myfree (exec_path);
5412
5413 /**
5414 * kernel cache, we need to make sure folder exist
5415 */
5416
5417 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5418
5419 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5420
5421 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5422
5423 mkdir (kernels_folder, 0700);
5424
5425 myfree (kernels_folder);
5426
5427 /**
5428 * session
5429 */
5430
5431 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5432
5433 data.session = session;
5434
5435 char *eff_restore_file = (char *) mymalloc (session_size);
5436 char *new_restore_file = (char *) mymalloc (session_size);
5437
5438 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5439 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5440
5441 data.eff_restore_file = eff_restore_file;
5442 data.new_restore_file = new_restore_file;
5443
5444 if (((show == 1) || (left == 1)) && (restore == 1))
5445 {
5446 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5447 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5448
5449 return (-1);
5450 }
5451
5452 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5453 if ((show == 1) || (left == 1))
5454 {
5455 restore_disable = 1;
5456
5457 restore = 0;
5458 }
5459
5460 data.restore_disable = restore_disable;
5461
5462 restore_data_t *rd = init_restore (argc, argv);
5463
5464 data.rd = rd;
5465
5466 /**
5467 * restore file
5468 */
5469
5470 if (restore == 1)
5471 {
5472 read_restore (eff_restore_file, rd);
5473
5474 if (rd->version_bin < RESTORE_MIN)
5475 {
5476 log_error ("ERROR: Incompatible restore-file version");
5477
5478 return (-1);
5479 }
5480
5481 myargc = rd->argc;
5482 myargv = rd->argv;
5483
5484 #ifdef _POSIX
5485 rd->pid = getpid ();
5486 #elif _WIN
5487 rd->pid = GetCurrentProcessId ();
5488 #endif
5489 }
5490
5491 uint hash_mode_chgd = 0;
5492 uint runtime_chgd = 0;
5493 uint kernel_loops_chgd = 0;
5494 uint kernel_accel_chgd = 0;
5495 uint attack_mode_chgd = 0;
5496 uint outfile_format_chgd = 0;
5497 uint rp_gen_seed_chgd = 0;
5498 uint remove_timer_chgd = 0;
5499 uint increment_min_chgd = 0;
5500 uint increment_max_chgd = 0;
5501 uint gpu_temp_abort_chgd = 0;
5502 uint gpu_temp_retain_chgd = 0;
5503
5504 optind = 1;
5505 optopt = 0;
5506 option_index = 0;
5507
5508 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5509 {
5510 switch (c)
5511 {
5512 //case IDX_HELP: usage = 1; break;
5513 //case IDX_VERSION: version = 1; break;
5514 //case IDX_RESTORE: restore = 1; break;
5515 case IDX_QUIET: quiet = 1; break;
5516 //case IDX_SHOW: show = 1; break;
5517 case IDX_SHOW: break;
5518 //case IDX_LEFT: left = 1; break;
5519 case IDX_LEFT: break;
5520 case IDX_USERNAME: username = 1; break;
5521 case IDX_REMOVE: remove = 1; break;
5522 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5523 remove_timer_chgd = 1; break;
5524 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5525 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5526 case IDX_DEBUG_FILE: debug_file = optarg; break;
5527 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5528 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5529 case IDX_FORCE: force = 1; break;
5530 case IDX_SKIP: skip = atoll (optarg); break;
5531 case IDX_LIMIT: limit = atoll (optarg); break;
5532 case IDX_KEYSPACE: keyspace = 1; break;
5533 case IDX_BENCHMARK: benchmark = 1; break;
5534 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5535 case IDX_RESTORE: break;
5536 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5537 case IDX_STATUS: status = 1; break;
5538 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5539 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5540 case IDX_LOOPBACK: loopback = 1; break;
5541 case IDX_WEAK_HASH_THRESHOLD:
5542 weak_hash_threshold = atoi (optarg); break;
5543 //case IDX_SESSION: session = optarg; break;
5544 case IDX_SESSION: break;
5545 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5546 hash_mode_chgd = 1; break;
5547 case IDX_RUNTIME: runtime = atoi (optarg);
5548 runtime_chgd = 1; break;
5549 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5550 attack_mode_chgd = 1; break;
5551 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5552 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5553 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5554 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5555 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5556 rp_gen_seed_chgd = 1; break;
5557 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5558 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5559 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5560 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5561 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5562 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5563 case IDX_OUTFILE: outfile = optarg; break;
5564 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5565 outfile_format_chgd = 1; break;
5566 case IDX_OUTFILE_AUTOHEX_DISABLE:
5567 outfile_autohex = 0; break;
5568 case IDX_OUTFILE_CHECK_TIMER:
5569 outfile_check_timer = atoi (optarg); break;
5570 case IDX_HEX_CHARSET: hex_charset = 1; break;
5571 case IDX_HEX_SALT: hex_salt = 1; break;
5572 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5573 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5574 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5575 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5576 case IDX_OPENCL_DEVICE_TYPES:
5577 opencl_device_types = optarg; break;
5578 case IDX_OPENCL_VECTOR_WIDTH:
5579 opencl_vector_width = atoi (optarg); break;
5580 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5581 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5582 kernel_accel_chgd = 1; break;
5583 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5584 kernel_loops_chgd = 1; break;
5585 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5586 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5587 gpu_temp_abort = atoi (optarg); break;
5588 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5589 gpu_temp_retain = atoi (optarg); break;
5590 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5591 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5592 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5593 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5594 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5595 case IDX_SEPARATOR: separator = optarg[0]; break;
5596 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5597 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5598 case IDX_INCREMENT: increment = 1; break;
5599 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5600 increment_min_chgd = 1; break;
5601 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5602 increment_max_chgd = 1; break;
5603 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5604 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5605 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5606 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5607
5608 default:
5609 log_error ("ERROR: Invalid argument specified");
5610 return (-1);
5611 }
5612 }
5613
5614 if (optopt != 0)
5615 {
5616 log_error ("ERROR: Invalid argument specified");
5617
5618 return (-1);
5619 }
5620
5621 /**
5622 * Inform user things getting started,
5623 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5624 * - we do not need to check algorithm_pos
5625 */
5626
5627 if (quiet == 0)
5628 {
5629 if (benchmark == 1)
5630 {
5631 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5632
5633 log_info ("");
5634 }
5635 else if (restore == 1)
5636 {
5637 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5638
5639 log_info ("");
5640 }
5641 else
5642 {
5643 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5644
5645 log_info ("");
5646 }
5647 }
5648
5649 /**
5650 * sanity check
5651 */
5652
5653 if (attack_mode > 7)
5654 {
5655 log_error ("ERROR: Invalid attack-mode specified");
5656
5657 return (-1);
5658 }
5659
5660 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5661 {
5662 log_error ("ERROR: Invalid runtime specified");
5663
5664 return (-1);
5665 }
5666
5667 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5668 {
5669 log_error ("ERROR: Invalid hash-type specified");
5670
5671 return (-1);
5672 }
5673
5674 // renamed hash modes
5675
5676 if (hash_mode_chgd)
5677 {
5678 int n = -1;
5679
5680 switch (hash_mode)
5681 {
5682 case 123: n = 124;
5683 break;
5684 }
5685
5686 if (n >= 0)
5687 {
5688 log_error ("Old -m specified, use -m %d instead", n);
5689
5690 return (-1);
5691 }
5692 }
5693
5694 if (username == 1)
5695 {
5696 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5697 {
5698 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5699
5700 return (-1);
5701 }
5702 }
5703
5704 if (outfile_format > 16)
5705 {
5706 log_error ("ERROR: Invalid outfile-format specified");
5707
5708 return (-1);
5709 }
5710
5711 if (left == 1)
5712 {
5713 if (outfile_format_chgd == 1)
5714 {
5715 if (outfile_format > 1)
5716 {
5717 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5718
5719 return (-1);
5720 }
5721 }
5722 else
5723 {
5724 outfile_format = OUTFILE_FMT_HASH;
5725 }
5726 }
5727
5728 if (show == 1)
5729 {
5730 if (outfile_format_chgd == 1)
5731 {
5732 if ((outfile_format > 7) && (outfile_format < 16))
5733 {
5734 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5735
5736 return (-1);
5737 }
5738 }
5739 }
5740
5741 if (increment_min < INCREMENT_MIN)
5742 {
5743 log_error ("ERROR: Invalid increment-min specified");
5744
5745 return (-1);
5746 }
5747
5748 if (increment_max > INCREMENT_MAX)
5749 {
5750 log_error ("ERROR: Invalid increment-max specified");
5751
5752 return (-1);
5753 }
5754
5755 if (increment_min > increment_max)
5756 {
5757 log_error ("ERROR: Invalid increment-min specified");
5758
5759 return (-1);
5760 }
5761
5762 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5763 {
5764 log_error ("ERROR: increment is not allowed in attack-mode 0");
5765
5766 return (-1);
5767 }
5768
5769 if ((increment == 0) && (increment_min_chgd == 1))
5770 {
5771 log_error ("ERROR: increment-min is only supported together with increment switch");
5772
5773 return (-1);
5774 }
5775
5776 if ((increment == 0) && (increment_max_chgd == 1))
5777 {
5778 log_error ("ERROR: increment-max is only supported together with increment switch");
5779
5780 return (-1);
5781 }
5782
5783 if (rp_files_cnt && rp_gen)
5784 {
5785 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5786
5787 return (-1);
5788 }
5789
5790 if (rp_files_cnt || rp_gen)
5791 {
5792 if (attack_mode != ATTACK_MODE_STRAIGHT)
5793 {
5794 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5795
5796 return (-1);
5797 }
5798 }
5799
5800 if (rp_gen_func_min > rp_gen_func_max)
5801 {
5802 log_error ("ERROR: Invalid rp-gen-func-min specified");
5803
5804 return (-1);
5805 }
5806
5807 if (kernel_accel_chgd == 1)
5808 {
5809 if (workload_profile != WORKLOAD_PROFILE)
5810 {
5811 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5812
5813 return (-1);
5814 }
5815
5816 if (kernel_accel < 1)
5817 {
5818 log_error ("ERROR: Invalid kernel-accel specified");
5819
5820 return (-1);
5821 }
5822
5823 if (kernel_accel > 800)
5824 {
5825 log_error ("ERROR: Invalid kernel-accel specified");
5826
5827 return (-1);
5828 }
5829 }
5830
5831 if (kernel_loops_chgd == 1)
5832 {
5833 if (workload_profile != WORKLOAD_PROFILE)
5834 {
5835 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5836
5837 return (-1);
5838 }
5839
5840 if (kernel_loops < 1)
5841 {
5842 log_error ("ERROR: Invalid kernel-loops specified");
5843
5844 return (-1);
5845 }
5846
5847 if (kernel_loops > 1024)
5848 {
5849 log_error ("ERROR: Invalid kernel-loops specified");
5850
5851 return (-1);
5852 }
5853 }
5854
5855 if (benchmark == 1)
5856 {
5857 if (workload_profile != WORKLOAD_PROFILE)
5858 {
5859 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5860
5861 return (-1);
5862 }
5863 }
5864
5865 if ((workload_profile < 1) || (workload_profile > 3))
5866 {
5867 log_error ("ERROR: workload-profile %i not available", workload_profile);
5868
5869 return (-1);
5870 }
5871
5872 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
5873 {
5874 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
5875
5876 return (-1);
5877 }
5878
5879 if (show == 1 || left == 1)
5880 {
5881 attack_mode = ATTACK_MODE_NONE;
5882
5883 if (remove == 1)
5884 {
5885 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5886
5887 return (-1);
5888 }
5889
5890 if (potfile_disable == 1)
5891 {
5892 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5893
5894 return (-1);
5895 }
5896 }
5897
5898 uint attack_kern = ATTACK_KERN_NONE;
5899
5900 switch (attack_mode)
5901 {
5902 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5903 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5904 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5905 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5906 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5907 }
5908
5909 if (benchmark == 0)
5910 {
5911 if (keyspace == 1)
5912 {
5913 int num_additional_params = 1;
5914
5915 if (attack_kern == ATTACK_KERN_COMBI)
5916 {
5917 num_additional_params = 2;
5918 }
5919
5920 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5921
5922 if (keyspace_wordlist_specified == 0) optind--;
5923 }
5924
5925 if (attack_kern == ATTACK_KERN_NONE)
5926 {
5927 if ((optind + 1) != myargc)
5928 {
5929 usage_mini_print (myargv[0]);
5930
5931 return (-1);
5932 }
5933 }
5934 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5935 {
5936 if ((optind + 1) > myargc)
5937 {
5938 usage_mini_print (myargv[0]);
5939
5940 return (-1);
5941 }
5942 }
5943 else if (attack_kern == ATTACK_KERN_COMBI)
5944 {
5945 if ((optind + 3) != myargc)
5946 {
5947 usage_mini_print (myargv[0]);
5948
5949 return (-1);
5950 }
5951 }
5952 else if (attack_kern == ATTACK_KERN_BF)
5953 {
5954 if ((optind + 1) > myargc)
5955 {
5956 usage_mini_print (myargv[0]);
5957
5958 return (-1);
5959 }
5960 }
5961 else
5962 {
5963 usage_mini_print (myargv[0]);
5964
5965 return (-1);
5966 }
5967 }
5968 else
5969 {
5970 if (myargv[optind] != 0)
5971 {
5972 log_error ("ERROR: Invalid argument for benchmark mode specified");
5973
5974 return (-1);
5975 }
5976
5977 if (attack_mode_chgd == 1)
5978 {
5979 if (attack_mode != ATTACK_MODE_BF)
5980 {
5981 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5982
5983 return (-1);
5984 }
5985 }
5986
5987 if (benchmark_mode == 0)
5988 {
5989 // nothing to do
5990 }
5991 else if (benchmark_mode == 1)
5992 {
5993 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
5994 {
5995 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
5996
5997 return (-1);
5998 }
5999 }
6000 else
6001 {
6002 log_error ("ERROR: Benchmark-mode must be 0 or 1");
6003
6004 return (-1);
6005 }
6006 }
6007
6008 if (skip != 0 && limit != 0)
6009 {
6010 limit += skip;
6011 }
6012
6013 if (keyspace == 1)
6014 {
6015 if (show == 1)
6016 {
6017 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6018
6019 return (-1);
6020 }
6021 else if (left == 1)
6022 {
6023 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6024
6025 return (-1);
6026 }
6027
6028 potfile_disable = 1;
6029
6030 restore_disable = 1;
6031
6032 restore = 0;
6033
6034 weak_hash_threshold = 0;
6035
6036 quiet = 1;
6037 }
6038
6039 if (remove_timer_chgd == 1)
6040 {
6041 if (remove == 0)
6042 {
6043 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6044
6045 return (-1);
6046 }
6047
6048 if (remove_timer < 1)
6049 {
6050 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6051
6052 return (-1);
6053 }
6054 }
6055
6056 if (loopback == 1)
6057 {
6058 if (attack_mode == ATTACK_MODE_BF)
6059 {
6060 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6061
6062 return (-1);
6063 }
6064 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6065 {
6066 if ((rp_files_cnt == 0) && (rp_gen == 0))
6067 {
6068 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6069
6070 return (-1);
6071 }
6072 }
6073 }
6074
6075 if (debug_mode > 0)
6076 {
6077 if (attack_mode != ATTACK_MODE_STRAIGHT)
6078 {
6079 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6080
6081 return (-1);
6082 }
6083
6084 if ((rp_files_cnt == 0) && (rp_gen == 0))
6085 {
6086 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6087
6088 return (-1);
6089 }
6090 }
6091
6092 if (debug_mode > 4)
6093 {
6094 log_error ("ERROR: Invalid debug-mode specified");
6095
6096 return (-1);
6097 }
6098
6099 if (debug_file != NULL)
6100 {
6101 if (debug_mode < 1)
6102 {
6103 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6104
6105 return (-1);
6106 }
6107 }
6108
6109 if (induction_dir != NULL)
6110 {
6111 if (attack_mode == ATTACK_MODE_BF)
6112 {
6113 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6114
6115 return (-1);
6116 }
6117 }
6118
6119 if (attack_mode != ATTACK_MODE_STRAIGHT)
6120 {
6121 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6122 {
6123 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6124
6125 return (-1);
6126 }
6127
6128 weak_hash_threshold = 0;
6129 }
6130
6131 /**
6132 * induction directory
6133 */
6134
6135 char *induction_directory = NULL;
6136
6137 if (attack_mode != ATTACK_MODE_BF)
6138 {
6139 if (induction_dir == NULL)
6140 {
6141 induction_directory = (char *) mymalloc (session_size);
6142
6143 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6144
6145 // create induction folder if it does not already exist
6146
6147 if (keyspace == 0)
6148 {
6149 if (rmdir (induction_directory) == -1)
6150 {
6151 if (errno == ENOENT)
6152 {
6153 // good, we can ignore
6154 }
6155 else if (errno == ENOTEMPTY)
6156 {
6157 char *induction_directory_mv = (char *) mymalloc (session_size);
6158
6159 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6160
6161 if (rename (induction_directory, induction_directory_mv) != 0)
6162 {
6163 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6164
6165 return (-1);
6166 }
6167 }
6168 else
6169 {
6170 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6171
6172 return (-1);
6173 }
6174 }
6175
6176 if (mkdir (induction_directory, 0700) == -1)
6177 {
6178 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6179
6180 return (-1);
6181 }
6182 }
6183 }
6184 else
6185 {
6186 induction_directory = induction_dir;
6187 }
6188 }
6189
6190 data.induction_directory = induction_directory;
6191
6192 /**
6193 * loopback
6194 */
6195
6196 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6197
6198 char *loopback_file = (char *) mymalloc (loopback_size);
6199
6200 /**
6201 * outfile-check directory
6202 */
6203
6204 char *outfile_check_directory = NULL;
6205
6206 if (outfile_check_dir == NULL)
6207 {
6208 outfile_check_directory = (char *) mymalloc (session_size);
6209
6210 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6211 }
6212 else
6213 {
6214 outfile_check_directory = outfile_check_dir;
6215 }
6216
6217 data.outfile_check_directory = outfile_check_directory;
6218
6219 if (keyspace == 0)
6220 {
6221 struct stat outfile_check_stat;
6222
6223 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6224 {
6225 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6226
6227 if (is_dir == 0)
6228 {
6229 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6230
6231 return (-1);
6232 }
6233 }
6234 else if (outfile_check_dir == NULL)
6235 {
6236 if (mkdir (outfile_check_directory, 0700) == -1)
6237 {
6238 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6239
6240 return (-1);
6241 }
6242 }
6243 }
6244
6245 /**
6246 * special other stuff
6247 */
6248
6249 if (hash_mode == 9710)
6250 {
6251 outfile_format = 5;
6252 outfile_format_chgd = 1;
6253 }
6254
6255 if (hash_mode == 9810)
6256 {
6257 outfile_format = 5;
6258 outfile_format_chgd = 1;
6259 }
6260
6261 if (hash_mode == 10410)
6262 {
6263 outfile_format = 5;
6264 outfile_format_chgd = 1;
6265 }
6266
6267 /**
6268 * store stuff
6269 */
6270
6271 data.hash_mode = hash_mode;
6272 data.restore = restore;
6273 data.restore_timer = restore_timer;
6274 data.restore_disable = restore_disable;
6275 data.status = status;
6276 data.status_timer = status_timer;
6277 data.status_automat = status_automat;
6278 data.loopback = loopback;
6279 data.runtime = runtime;
6280 data.remove = remove;
6281 data.remove_timer = remove_timer;
6282 data.debug_mode = debug_mode;
6283 data.debug_file = debug_file;
6284 data.username = username;
6285 data.quiet = quiet;
6286 data.outfile = outfile;
6287 data.outfile_format = outfile_format;
6288 data.outfile_autohex = outfile_autohex;
6289 data.hex_charset = hex_charset;
6290 data.hex_salt = hex_salt;
6291 data.hex_wordlist = hex_wordlist;
6292 data.separator = separator;
6293 data.rp_files = rp_files;
6294 data.rp_files_cnt = rp_files_cnt;
6295 data.rp_gen = rp_gen;
6296 data.rp_gen_seed = rp_gen_seed;
6297 data.force = force;
6298 data.benchmark = benchmark;
6299 data.skip = skip;
6300 data.limit = limit;
6301 data.powertune_enable = powertune_enable;
6302 data.logfile_disable = logfile_disable;
6303 data.truecrypt_keyfiles = truecrypt_keyfiles;
6304 data.scrypt_tmto = scrypt_tmto;
6305
6306 /**
6307 * cpu affinity
6308 */
6309
6310 if (cpu_affinity)
6311 {
6312 set_cpu_affinity (cpu_affinity);
6313 }
6314
6315 if (rp_gen_seed_chgd == 0)
6316 {
6317 srand (proc_start);
6318 }
6319 else
6320 {
6321 srand (rp_gen_seed);
6322 }
6323
6324 /**
6325 * logfile init
6326 */
6327
6328 if (logfile_disable == 0)
6329 {
6330 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6331
6332 char *logfile = (char *) mymalloc (logfile_size);
6333
6334 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6335
6336 data.logfile = logfile;
6337
6338 char *topid = logfile_generate_topid ();
6339
6340 data.topid = topid;
6341 }
6342
6343 // logfile_append() checks for logfile_disable internally to make it easier from here
6344
6345 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6346 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6347 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6348 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6349 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6350 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6351 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6352 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6353 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6354 #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));
6355
6356 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6357 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6358 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6359 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6360 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6361 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6362 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6363 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6364
6365 logfile_top_msg ("START");
6366
6367 logfile_top_uint (attack_mode);
6368 logfile_top_uint (attack_kern);
6369 logfile_top_uint (benchmark);
6370 logfile_top_uint (benchmark_mode);
6371 logfile_top_uint (bitmap_min);
6372 logfile_top_uint (bitmap_max);
6373 logfile_top_uint (debug_mode);
6374 logfile_top_uint (force);
6375 logfile_top_uint (kernel_accel);
6376 logfile_top_uint (kernel_loops);
6377 logfile_top_uint (gpu_temp_abort);
6378 logfile_top_uint (gpu_temp_disable);
6379 logfile_top_uint (gpu_temp_retain);
6380 logfile_top_uint (hash_mode);
6381 logfile_top_uint (hex_charset);
6382 logfile_top_uint (hex_salt);
6383 logfile_top_uint (hex_wordlist);
6384 logfile_top_uint (increment);
6385 logfile_top_uint (increment_max);
6386 logfile_top_uint (increment_min);
6387 logfile_top_uint (keyspace);
6388 logfile_top_uint (left);
6389 logfile_top_uint (logfile_disable);
6390 logfile_top_uint (loopback);
6391 logfile_top_uint (markov_classic);
6392 logfile_top_uint (markov_disable);
6393 logfile_top_uint (markov_threshold);
6394 logfile_top_uint (outfile_autohex);
6395 logfile_top_uint (outfile_check_timer);
6396 logfile_top_uint (outfile_format);
6397 logfile_top_uint (potfile_disable);
6398 logfile_top_uint (powertune_enable);
6399 logfile_top_uint (scrypt_tmto);
6400 logfile_top_uint (quiet);
6401 logfile_top_uint (remove);
6402 logfile_top_uint (remove_timer);
6403 logfile_top_uint (restore);
6404 logfile_top_uint (restore_disable);
6405 logfile_top_uint (restore_timer);
6406 logfile_top_uint (rp_gen);
6407 logfile_top_uint (rp_gen_func_max);
6408 logfile_top_uint (rp_gen_func_min);
6409 logfile_top_uint (rp_gen_seed);
6410 logfile_top_uint (runtime);
6411 logfile_top_uint (segment_size);
6412 logfile_top_uint (show);
6413 logfile_top_uint (status);
6414 logfile_top_uint (status_automat);
6415 logfile_top_uint (status_timer);
6416 logfile_top_uint (usage);
6417 logfile_top_uint (username);
6418 logfile_top_uint (version);
6419 logfile_top_uint (weak_hash_threshold);
6420 logfile_top_uint (workload_profile);
6421 logfile_top_uint64 (limit);
6422 logfile_top_uint64 (skip);
6423 logfile_top_char (separator);
6424 logfile_top_string (cpu_affinity);
6425 logfile_top_string (custom_charset_1);
6426 logfile_top_string (custom_charset_2);
6427 logfile_top_string (custom_charset_3);
6428 logfile_top_string (custom_charset_4);
6429 logfile_top_string (debug_file);
6430 logfile_top_string (opencl_devices);
6431 logfile_top_string (opencl_platforms);
6432 logfile_top_string (opencl_device_types);
6433 logfile_top_uint (opencl_vector_width);
6434 logfile_top_string (induction_dir);
6435 logfile_top_string (markov_hcstat);
6436 logfile_top_string (outfile);
6437 logfile_top_string (outfile_check_dir);
6438 logfile_top_string (rule_buf_l);
6439 logfile_top_string (rule_buf_r);
6440 logfile_top_string (session);
6441 logfile_top_string (truecrypt_keyfiles);
6442
6443 /**
6444 * OpenCL platform selection
6445 */
6446
6447 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6448
6449 /**
6450 * OpenCL device selection
6451 */
6452
6453 u32 devices_filter = setup_devices_filter (opencl_devices);
6454
6455 /**
6456 * OpenCL device type selection
6457 */
6458
6459 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6460
6461 /**
6462 * benchmark
6463 */
6464
6465 if (benchmark == 1)
6466 {
6467 /**
6468 * disable useless stuff for benchmark
6469 */
6470
6471 restore_timer = 0;
6472 status_timer = 0;
6473 restore_disable = 1;
6474 potfile_disable = 1;
6475 weak_hash_threshold = 0;
6476
6477 data.restore_timer = restore_timer;
6478 data.status_timer = status_timer;
6479 data.restore_disable = restore_disable;
6480
6481 if (benchmark_mode == 1)
6482 {
6483 markov_disable = 1;
6484 }
6485
6486 /**
6487 * force attack mode to be bruteforce
6488 */
6489
6490 attack_mode = ATTACK_MODE_BF;
6491 attack_kern = ATTACK_KERN_BF;
6492
6493 if (runtime_chgd == 0)
6494 {
6495 runtime = 4;
6496
6497 if (benchmark_mode == 1) runtime = 17;
6498
6499 data.runtime = runtime;
6500 }
6501 }
6502
6503 /**
6504 * config
6505 */
6506
6507 uint hash_type = 0;
6508 uint salt_type = 0;
6509 uint attack_exec = 0;
6510 uint opts_type = 0;
6511 uint kern_type = 0;
6512 uint dgst_size = 0;
6513 uint esalt_size = 0;
6514 uint opti_type = 0;
6515 uint dgst_pos0 = -1;
6516 uint dgst_pos1 = -1;
6517 uint dgst_pos2 = -1;
6518 uint dgst_pos3 = -1;
6519
6520 int (*parse_func) (char *, uint, hash_t *);
6521 int (*sort_by_digest) (const void *, const void *);
6522
6523 uint algorithm_pos = 0;
6524 uint algorithm_max = 1;
6525
6526 uint *algorithms = default_benchmark_algorithms;
6527
6528 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6529
6530 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6531 {
6532 /*
6533 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6534 * the following algos are skipped entirely
6535 */
6536
6537 if (algorithm_pos > 0)
6538 {
6539 local_free (rd);
6540
6541 rd = init_restore (argc, argv);
6542
6543 data.rd = rd;
6544 }
6545
6546 /**
6547 * update hash_mode in case of multihash benchmark
6548 */
6549
6550 if (benchmark == 1)
6551 {
6552 if (hash_mode_chgd == 0)
6553 {
6554 hash_mode = algorithms[algorithm_pos];
6555
6556 data.hash_mode = hash_mode;
6557 }
6558
6559 quiet = 1;
6560
6561 data.quiet = quiet;
6562 }
6563
6564 switch (hash_mode)
6565 {
6566 case 0: hash_type = HASH_TYPE_MD5;
6567 salt_type = SALT_TYPE_NONE;
6568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6569 opts_type = OPTS_TYPE_PT_GENERATE_LE
6570 | OPTS_TYPE_PT_ADD80
6571 | OPTS_TYPE_PT_ADDBITS14;
6572 kern_type = KERN_TYPE_MD5;
6573 dgst_size = DGST_SIZE_4_4;
6574 parse_func = md5_parse_hash;
6575 sort_by_digest = sort_by_digest_4_4;
6576 opti_type = OPTI_TYPE_ZERO_BYTE
6577 | OPTI_TYPE_PRECOMPUTE_INIT
6578 | OPTI_TYPE_PRECOMPUTE_MERKLE
6579 | OPTI_TYPE_MEET_IN_MIDDLE
6580 | OPTI_TYPE_EARLY_SKIP
6581 | OPTI_TYPE_NOT_ITERATED
6582 | OPTI_TYPE_NOT_SALTED
6583 | OPTI_TYPE_RAW_HASH;
6584 dgst_pos0 = 0;
6585 dgst_pos1 = 3;
6586 dgst_pos2 = 2;
6587 dgst_pos3 = 1;
6588 break;
6589
6590 case 10: hash_type = HASH_TYPE_MD5;
6591 salt_type = SALT_TYPE_INTERN;
6592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6593 opts_type = OPTS_TYPE_PT_GENERATE_LE
6594 | OPTS_TYPE_ST_ADD80
6595 | OPTS_TYPE_ST_ADDBITS14;
6596 kern_type = KERN_TYPE_MD5_PWSLT;
6597 dgst_size = DGST_SIZE_4_4;
6598 parse_func = md5s_parse_hash;
6599 sort_by_digest = sort_by_digest_4_4;
6600 opti_type = OPTI_TYPE_ZERO_BYTE
6601 | OPTI_TYPE_PRECOMPUTE_INIT
6602 | OPTI_TYPE_PRECOMPUTE_MERKLE
6603 | OPTI_TYPE_MEET_IN_MIDDLE
6604 | OPTI_TYPE_EARLY_SKIP
6605 | OPTI_TYPE_NOT_ITERATED
6606 | OPTI_TYPE_APPENDED_SALT
6607 | OPTI_TYPE_RAW_HASH;
6608 dgst_pos0 = 0;
6609 dgst_pos1 = 3;
6610 dgst_pos2 = 2;
6611 dgst_pos3 = 1;
6612 break;
6613
6614 case 11: hash_type = HASH_TYPE_MD5;
6615 salt_type = SALT_TYPE_INTERN;
6616 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6617 opts_type = OPTS_TYPE_PT_GENERATE_LE
6618 | OPTS_TYPE_ST_ADD80
6619 | OPTS_TYPE_ST_ADDBITS14;
6620 kern_type = KERN_TYPE_MD5_PWSLT;
6621 dgst_size = DGST_SIZE_4_4;
6622 parse_func = joomla_parse_hash;
6623 sort_by_digest = sort_by_digest_4_4;
6624 opti_type = OPTI_TYPE_ZERO_BYTE
6625 | OPTI_TYPE_PRECOMPUTE_INIT
6626 | OPTI_TYPE_PRECOMPUTE_MERKLE
6627 | OPTI_TYPE_MEET_IN_MIDDLE
6628 | OPTI_TYPE_EARLY_SKIP
6629 | OPTI_TYPE_NOT_ITERATED
6630 | OPTI_TYPE_APPENDED_SALT
6631 | OPTI_TYPE_RAW_HASH;
6632 dgst_pos0 = 0;
6633 dgst_pos1 = 3;
6634 dgst_pos2 = 2;
6635 dgst_pos3 = 1;
6636 break;
6637
6638 case 12: hash_type = HASH_TYPE_MD5;
6639 salt_type = SALT_TYPE_INTERN;
6640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6641 opts_type = OPTS_TYPE_PT_GENERATE_LE
6642 | OPTS_TYPE_ST_ADD80
6643 | OPTS_TYPE_ST_ADDBITS14;
6644 kern_type = KERN_TYPE_MD5_PWSLT;
6645 dgst_size = DGST_SIZE_4_4;
6646 parse_func = postgresql_parse_hash;
6647 sort_by_digest = sort_by_digest_4_4;
6648 opti_type = OPTI_TYPE_ZERO_BYTE
6649 | OPTI_TYPE_PRECOMPUTE_INIT
6650 | OPTI_TYPE_PRECOMPUTE_MERKLE
6651 | OPTI_TYPE_MEET_IN_MIDDLE
6652 | OPTI_TYPE_EARLY_SKIP
6653 | OPTI_TYPE_NOT_ITERATED
6654 | OPTI_TYPE_APPENDED_SALT
6655 | OPTI_TYPE_RAW_HASH;
6656 dgst_pos0 = 0;
6657 dgst_pos1 = 3;
6658 dgst_pos2 = 2;
6659 dgst_pos3 = 1;
6660 break;
6661
6662 case 20: hash_type = HASH_TYPE_MD5;
6663 salt_type = SALT_TYPE_INTERN;
6664 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6665 opts_type = OPTS_TYPE_PT_GENERATE_LE
6666 | OPTS_TYPE_PT_ADD80
6667 | OPTS_TYPE_PT_ADDBITS14;
6668 kern_type = KERN_TYPE_MD5_SLTPW;
6669 dgst_size = DGST_SIZE_4_4;
6670 parse_func = md5s_parse_hash;
6671 sort_by_digest = sort_by_digest_4_4;
6672 opti_type = OPTI_TYPE_ZERO_BYTE
6673 | OPTI_TYPE_PRECOMPUTE_INIT
6674 | OPTI_TYPE_PRECOMPUTE_MERKLE
6675 | OPTI_TYPE_EARLY_SKIP
6676 | OPTI_TYPE_NOT_ITERATED
6677 | OPTI_TYPE_PREPENDED_SALT
6678 | OPTI_TYPE_RAW_HASH;
6679 dgst_pos0 = 0;
6680 dgst_pos1 = 3;
6681 dgst_pos2 = 2;
6682 dgst_pos3 = 1;
6683 break;
6684
6685 case 21: hash_type = HASH_TYPE_MD5;
6686 salt_type = SALT_TYPE_INTERN;
6687 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6688 opts_type = OPTS_TYPE_PT_GENERATE_LE
6689 | OPTS_TYPE_PT_ADD80
6690 | OPTS_TYPE_PT_ADDBITS14;
6691 kern_type = KERN_TYPE_MD5_SLTPW;
6692 dgst_size = DGST_SIZE_4_4;
6693 parse_func = osc_parse_hash;
6694 sort_by_digest = sort_by_digest_4_4;
6695 opti_type = OPTI_TYPE_ZERO_BYTE
6696 | OPTI_TYPE_PRECOMPUTE_INIT
6697 | OPTI_TYPE_PRECOMPUTE_MERKLE
6698 | OPTI_TYPE_EARLY_SKIP
6699 | OPTI_TYPE_NOT_ITERATED
6700 | OPTI_TYPE_PREPENDED_SALT
6701 | OPTI_TYPE_RAW_HASH;
6702 dgst_pos0 = 0;
6703 dgst_pos1 = 3;
6704 dgst_pos2 = 2;
6705 dgst_pos3 = 1;
6706 break;
6707
6708 case 22: hash_type = HASH_TYPE_MD5;
6709 salt_type = SALT_TYPE_EMBEDDED;
6710 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6711 opts_type = OPTS_TYPE_PT_GENERATE_LE
6712 | OPTS_TYPE_PT_ADD80
6713 | OPTS_TYPE_PT_ADDBITS14;
6714 kern_type = KERN_TYPE_MD5_SLTPW;
6715 dgst_size = DGST_SIZE_4_4;
6716 parse_func = netscreen_parse_hash;
6717 sort_by_digest = sort_by_digest_4_4;
6718 opti_type = OPTI_TYPE_ZERO_BYTE
6719 | OPTI_TYPE_PRECOMPUTE_INIT
6720 | OPTI_TYPE_PRECOMPUTE_MERKLE
6721 | OPTI_TYPE_EARLY_SKIP
6722 | OPTI_TYPE_NOT_ITERATED
6723 | OPTI_TYPE_PREPENDED_SALT
6724 | OPTI_TYPE_RAW_HASH;
6725 dgst_pos0 = 0;
6726 dgst_pos1 = 3;
6727 dgst_pos2 = 2;
6728 dgst_pos3 = 1;
6729 break;
6730
6731 case 23: hash_type = HASH_TYPE_MD5;
6732 salt_type = SALT_TYPE_EMBEDDED;
6733 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6734 opts_type = OPTS_TYPE_PT_GENERATE_LE
6735 | OPTS_TYPE_PT_ADD80
6736 | OPTS_TYPE_PT_ADDBITS14;
6737 kern_type = KERN_TYPE_MD5_SLTPW;
6738 dgst_size = DGST_SIZE_4_4;
6739 parse_func = skype_parse_hash;
6740 sort_by_digest = sort_by_digest_4_4;
6741 opti_type = OPTI_TYPE_ZERO_BYTE
6742 | OPTI_TYPE_PRECOMPUTE_INIT
6743 | OPTI_TYPE_PRECOMPUTE_MERKLE
6744 | OPTI_TYPE_EARLY_SKIP
6745 | OPTI_TYPE_NOT_ITERATED
6746 | OPTI_TYPE_PREPENDED_SALT
6747 | OPTI_TYPE_RAW_HASH;
6748 dgst_pos0 = 0;
6749 dgst_pos1 = 3;
6750 dgst_pos2 = 2;
6751 dgst_pos3 = 1;
6752 break;
6753
6754 case 30: hash_type = HASH_TYPE_MD5;
6755 salt_type = SALT_TYPE_INTERN;
6756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6757 opts_type = OPTS_TYPE_PT_GENERATE_LE
6758 | OPTS_TYPE_PT_UNICODE
6759 | OPTS_TYPE_ST_ADD80
6760 | OPTS_TYPE_ST_ADDBITS14;
6761 kern_type = KERN_TYPE_MD5_PWUSLT;
6762 dgst_size = DGST_SIZE_4_4;
6763 parse_func = md5s_parse_hash;
6764 sort_by_digest = sort_by_digest_4_4;
6765 opti_type = OPTI_TYPE_ZERO_BYTE
6766 | OPTI_TYPE_PRECOMPUTE_INIT
6767 | OPTI_TYPE_PRECOMPUTE_MERKLE
6768 | OPTI_TYPE_MEET_IN_MIDDLE
6769 | OPTI_TYPE_EARLY_SKIP
6770 | OPTI_TYPE_NOT_ITERATED
6771 | OPTI_TYPE_APPENDED_SALT
6772 | OPTI_TYPE_RAW_HASH;
6773 dgst_pos0 = 0;
6774 dgst_pos1 = 3;
6775 dgst_pos2 = 2;
6776 dgst_pos3 = 1;
6777 break;
6778
6779 case 40: hash_type = HASH_TYPE_MD5;
6780 salt_type = SALT_TYPE_INTERN;
6781 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6782 opts_type = OPTS_TYPE_PT_GENERATE_LE
6783 | OPTS_TYPE_PT_ADD80
6784 | OPTS_TYPE_PT_ADDBITS14
6785 | OPTS_TYPE_PT_UNICODE;
6786 kern_type = KERN_TYPE_MD5_SLTPWU;
6787 dgst_size = DGST_SIZE_4_4;
6788 parse_func = md5s_parse_hash;
6789 sort_by_digest = sort_by_digest_4_4;
6790 opti_type = OPTI_TYPE_ZERO_BYTE
6791 | OPTI_TYPE_PRECOMPUTE_INIT
6792 | OPTI_TYPE_PRECOMPUTE_MERKLE
6793 | OPTI_TYPE_EARLY_SKIP
6794 | OPTI_TYPE_NOT_ITERATED
6795 | OPTI_TYPE_PREPENDED_SALT
6796 | OPTI_TYPE_RAW_HASH;
6797 dgst_pos0 = 0;
6798 dgst_pos1 = 3;
6799 dgst_pos2 = 2;
6800 dgst_pos3 = 1;
6801 break;
6802
6803 case 50: hash_type = HASH_TYPE_MD5;
6804 salt_type = SALT_TYPE_INTERN;
6805 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6806 opts_type = OPTS_TYPE_PT_GENERATE_LE
6807 | OPTS_TYPE_ST_ADD80
6808 | OPTS_TYPE_ST_ADDBITS14;
6809 kern_type = KERN_TYPE_HMACMD5_PW;
6810 dgst_size = DGST_SIZE_4_4;
6811 parse_func = hmacmd5_parse_hash;
6812 sort_by_digest = sort_by_digest_4_4;
6813 opti_type = OPTI_TYPE_ZERO_BYTE
6814 | OPTI_TYPE_NOT_ITERATED;
6815 dgst_pos0 = 0;
6816 dgst_pos1 = 3;
6817 dgst_pos2 = 2;
6818 dgst_pos3 = 1;
6819 break;
6820
6821 case 60: hash_type = HASH_TYPE_MD5;
6822 salt_type = SALT_TYPE_INTERN;
6823 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6824 opts_type = OPTS_TYPE_PT_GENERATE_LE
6825 | OPTS_TYPE_PT_ADD80
6826 | OPTS_TYPE_PT_ADDBITS14;
6827 kern_type = KERN_TYPE_HMACMD5_SLT;
6828 dgst_size = DGST_SIZE_4_4;
6829 parse_func = hmacmd5_parse_hash;
6830 sort_by_digest = sort_by_digest_4_4;
6831 opti_type = OPTI_TYPE_ZERO_BYTE
6832 | OPTI_TYPE_NOT_ITERATED;
6833 dgst_pos0 = 0;
6834 dgst_pos1 = 3;
6835 dgst_pos2 = 2;
6836 dgst_pos3 = 1;
6837 break;
6838
6839 case 100: hash_type = HASH_TYPE_SHA1;
6840 salt_type = SALT_TYPE_NONE;
6841 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6842 opts_type = OPTS_TYPE_PT_GENERATE_BE
6843 | OPTS_TYPE_PT_ADD80
6844 | OPTS_TYPE_PT_ADDBITS15;
6845 kern_type = KERN_TYPE_SHA1;
6846 dgst_size = DGST_SIZE_4_5;
6847 parse_func = sha1_parse_hash;
6848 sort_by_digest = sort_by_digest_4_5;
6849 opti_type = OPTI_TYPE_ZERO_BYTE
6850 | OPTI_TYPE_PRECOMPUTE_INIT
6851 | OPTI_TYPE_PRECOMPUTE_MERKLE
6852 | OPTI_TYPE_EARLY_SKIP
6853 | OPTI_TYPE_NOT_ITERATED
6854 | OPTI_TYPE_NOT_SALTED
6855 | OPTI_TYPE_RAW_HASH;
6856 dgst_pos0 = 3;
6857 dgst_pos1 = 4;
6858 dgst_pos2 = 2;
6859 dgst_pos3 = 1;
6860 break;
6861
6862 case 101: hash_type = HASH_TYPE_SHA1;
6863 salt_type = SALT_TYPE_NONE;
6864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6865 opts_type = OPTS_TYPE_PT_GENERATE_BE
6866 | OPTS_TYPE_PT_ADD80
6867 | OPTS_TYPE_PT_ADDBITS15;
6868 kern_type = KERN_TYPE_SHA1;
6869 dgst_size = DGST_SIZE_4_5;
6870 parse_func = sha1b64_parse_hash;
6871 sort_by_digest = sort_by_digest_4_5;
6872 opti_type = OPTI_TYPE_ZERO_BYTE
6873 | OPTI_TYPE_PRECOMPUTE_INIT
6874 | OPTI_TYPE_PRECOMPUTE_MERKLE
6875 | OPTI_TYPE_EARLY_SKIP
6876 | OPTI_TYPE_NOT_ITERATED
6877 | OPTI_TYPE_NOT_SALTED
6878 | OPTI_TYPE_RAW_HASH;
6879 dgst_pos0 = 3;
6880 dgst_pos1 = 4;
6881 dgst_pos2 = 2;
6882 dgst_pos3 = 1;
6883 break;
6884
6885 case 110: hash_type = HASH_TYPE_SHA1;
6886 salt_type = SALT_TYPE_INTERN;
6887 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6888 opts_type = OPTS_TYPE_PT_GENERATE_BE
6889 | OPTS_TYPE_ST_ADD80
6890 | OPTS_TYPE_ST_ADDBITS15;
6891 kern_type = KERN_TYPE_SHA1_PWSLT;
6892 dgst_size = DGST_SIZE_4_5;
6893 parse_func = sha1s_parse_hash;
6894 sort_by_digest = sort_by_digest_4_5;
6895 opti_type = OPTI_TYPE_ZERO_BYTE
6896 | OPTI_TYPE_PRECOMPUTE_INIT
6897 | OPTI_TYPE_PRECOMPUTE_MERKLE
6898 | OPTI_TYPE_EARLY_SKIP
6899 | OPTI_TYPE_NOT_ITERATED
6900 | OPTI_TYPE_APPENDED_SALT
6901 | OPTI_TYPE_RAW_HASH;
6902 dgst_pos0 = 3;
6903 dgst_pos1 = 4;
6904 dgst_pos2 = 2;
6905 dgst_pos3 = 1;
6906 break;
6907
6908 case 111: hash_type = HASH_TYPE_SHA1;
6909 salt_type = SALT_TYPE_EMBEDDED;
6910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6911 opts_type = OPTS_TYPE_PT_GENERATE_BE
6912 | OPTS_TYPE_ST_ADD80
6913 | OPTS_TYPE_ST_ADDBITS15;
6914 kern_type = KERN_TYPE_SHA1_PWSLT;
6915 dgst_size = DGST_SIZE_4_5;
6916 parse_func = sha1b64s_parse_hash;
6917 sort_by_digest = sort_by_digest_4_5;
6918 opti_type = OPTI_TYPE_ZERO_BYTE
6919 | OPTI_TYPE_PRECOMPUTE_INIT
6920 | OPTI_TYPE_PRECOMPUTE_MERKLE
6921 | OPTI_TYPE_EARLY_SKIP
6922 | OPTI_TYPE_NOT_ITERATED
6923 | OPTI_TYPE_APPENDED_SALT
6924 | OPTI_TYPE_RAW_HASH;
6925 dgst_pos0 = 3;
6926 dgst_pos1 = 4;
6927 dgst_pos2 = 2;
6928 dgst_pos3 = 1;
6929 break;
6930
6931 case 112: hash_type = HASH_TYPE_SHA1;
6932 salt_type = SALT_TYPE_INTERN;
6933 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6934 opts_type = OPTS_TYPE_PT_GENERATE_BE
6935 | OPTS_TYPE_ST_ADD80
6936 | OPTS_TYPE_ST_ADDBITS15
6937 | OPTS_TYPE_ST_HEX;
6938 kern_type = KERN_TYPE_SHA1_PWSLT;
6939 dgst_size = DGST_SIZE_4_5;
6940 parse_func = oracles_parse_hash;
6941 sort_by_digest = sort_by_digest_4_5;
6942 opti_type = OPTI_TYPE_ZERO_BYTE
6943 | OPTI_TYPE_PRECOMPUTE_INIT
6944 | OPTI_TYPE_PRECOMPUTE_MERKLE
6945 | OPTI_TYPE_EARLY_SKIP
6946 | OPTI_TYPE_NOT_ITERATED
6947 | OPTI_TYPE_APPENDED_SALT
6948 | OPTI_TYPE_RAW_HASH;
6949 dgst_pos0 = 3;
6950 dgst_pos1 = 4;
6951 dgst_pos2 = 2;
6952 dgst_pos3 = 1;
6953 break;
6954
6955 case 120: hash_type = HASH_TYPE_SHA1;
6956 salt_type = SALT_TYPE_INTERN;
6957 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6958 opts_type = OPTS_TYPE_PT_GENERATE_BE
6959 | OPTS_TYPE_PT_ADD80
6960 | OPTS_TYPE_PT_ADDBITS15;
6961 kern_type = KERN_TYPE_SHA1_SLTPW;
6962 dgst_size = DGST_SIZE_4_5;
6963 parse_func = sha1s_parse_hash;
6964 sort_by_digest = sort_by_digest_4_5;
6965 opti_type = OPTI_TYPE_ZERO_BYTE
6966 | OPTI_TYPE_PRECOMPUTE_INIT
6967 | OPTI_TYPE_PRECOMPUTE_MERKLE
6968 | OPTI_TYPE_EARLY_SKIP
6969 | OPTI_TYPE_NOT_ITERATED
6970 | OPTI_TYPE_PREPENDED_SALT
6971 | OPTI_TYPE_RAW_HASH;
6972 dgst_pos0 = 3;
6973 dgst_pos1 = 4;
6974 dgst_pos2 = 2;
6975 dgst_pos3 = 1;
6976 break;
6977
6978 case 121: hash_type = HASH_TYPE_SHA1;
6979 salt_type = SALT_TYPE_INTERN;
6980 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6981 opts_type = OPTS_TYPE_PT_GENERATE_BE
6982 | OPTS_TYPE_PT_ADD80
6983 | OPTS_TYPE_PT_ADDBITS15
6984 | OPTS_TYPE_ST_LOWER;
6985 kern_type = KERN_TYPE_SHA1_SLTPW;
6986 dgst_size = DGST_SIZE_4_5;
6987 parse_func = smf_parse_hash;
6988 sort_by_digest = sort_by_digest_4_5;
6989 opti_type = OPTI_TYPE_ZERO_BYTE
6990 | OPTI_TYPE_PRECOMPUTE_INIT
6991 | OPTI_TYPE_PRECOMPUTE_MERKLE
6992 | OPTI_TYPE_EARLY_SKIP
6993 | OPTI_TYPE_NOT_ITERATED
6994 | OPTI_TYPE_PREPENDED_SALT
6995 | OPTI_TYPE_RAW_HASH;
6996 dgst_pos0 = 3;
6997 dgst_pos1 = 4;
6998 dgst_pos2 = 2;
6999 dgst_pos3 = 1;
7000 break;
7001
7002 case 122: hash_type = HASH_TYPE_SHA1;
7003 salt_type = SALT_TYPE_EMBEDDED;
7004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7005 opts_type = OPTS_TYPE_PT_GENERATE_BE
7006 | OPTS_TYPE_PT_ADD80
7007 | OPTS_TYPE_PT_ADDBITS15
7008 | OPTS_TYPE_ST_HEX;
7009 kern_type = KERN_TYPE_SHA1_SLTPW;
7010 dgst_size = DGST_SIZE_4_5;
7011 parse_func = osx1_parse_hash;
7012 sort_by_digest = sort_by_digest_4_5;
7013 opti_type = OPTI_TYPE_ZERO_BYTE
7014 | OPTI_TYPE_PRECOMPUTE_INIT
7015 | OPTI_TYPE_PRECOMPUTE_MERKLE
7016 | OPTI_TYPE_EARLY_SKIP
7017 | OPTI_TYPE_NOT_ITERATED
7018 | OPTI_TYPE_PREPENDED_SALT
7019 | OPTI_TYPE_RAW_HASH;
7020 dgst_pos0 = 3;
7021 dgst_pos1 = 4;
7022 dgst_pos2 = 2;
7023 dgst_pos3 = 1;
7024 break;
7025
7026 case 124: hash_type = HASH_TYPE_SHA1;
7027 salt_type = SALT_TYPE_EMBEDDED;
7028 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7029 opts_type = OPTS_TYPE_PT_GENERATE_BE
7030 | OPTS_TYPE_PT_ADD80
7031 | OPTS_TYPE_PT_ADDBITS15;
7032 kern_type = KERN_TYPE_SHA1_SLTPW;
7033 dgst_size = DGST_SIZE_4_5;
7034 parse_func = djangosha1_parse_hash;
7035 sort_by_digest = sort_by_digest_4_5;
7036 opti_type = OPTI_TYPE_ZERO_BYTE
7037 | OPTI_TYPE_PRECOMPUTE_INIT
7038 | OPTI_TYPE_PRECOMPUTE_MERKLE
7039 | OPTI_TYPE_EARLY_SKIP
7040 | OPTI_TYPE_NOT_ITERATED
7041 | OPTI_TYPE_PREPENDED_SALT
7042 | OPTI_TYPE_RAW_HASH;
7043 dgst_pos0 = 3;
7044 dgst_pos1 = 4;
7045 dgst_pos2 = 2;
7046 dgst_pos3 = 1;
7047 break;
7048
7049 case 130: hash_type = HASH_TYPE_SHA1;
7050 salt_type = SALT_TYPE_INTERN;
7051 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7052 opts_type = OPTS_TYPE_PT_GENERATE_BE
7053 | OPTS_TYPE_PT_UNICODE
7054 | OPTS_TYPE_ST_ADD80
7055 | OPTS_TYPE_ST_ADDBITS15;
7056 kern_type = KERN_TYPE_SHA1_PWUSLT;
7057 dgst_size = DGST_SIZE_4_5;
7058 parse_func = sha1s_parse_hash;
7059 sort_by_digest = sort_by_digest_4_5;
7060 opti_type = OPTI_TYPE_ZERO_BYTE
7061 | OPTI_TYPE_PRECOMPUTE_INIT
7062 | OPTI_TYPE_PRECOMPUTE_MERKLE
7063 | OPTI_TYPE_EARLY_SKIP
7064 | OPTI_TYPE_NOT_ITERATED
7065 | OPTI_TYPE_APPENDED_SALT
7066 | OPTI_TYPE_RAW_HASH;
7067 dgst_pos0 = 3;
7068 dgst_pos1 = 4;
7069 dgst_pos2 = 2;
7070 dgst_pos3 = 1;
7071 break;
7072
7073 case 131: hash_type = HASH_TYPE_SHA1;
7074 salt_type = SALT_TYPE_EMBEDDED;
7075 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7076 opts_type = OPTS_TYPE_PT_GENERATE_BE
7077 | OPTS_TYPE_PT_UNICODE
7078 | OPTS_TYPE_PT_UPPER
7079 | OPTS_TYPE_ST_ADD80
7080 | OPTS_TYPE_ST_ADDBITS15
7081 | OPTS_TYPE_ST_HEX;
7082 kern_type = KERN_TYPE_SHA1_PWUSLT;
7083 dgst_size = DGST_SIZE_4_5;
7084 parse_func = mssql2000_parse_hash;
7085 sort_by_digest = sort_by_digest_4_5;
7086 opti_type = OPTI_TYPE_ZERO_BYTE
7087 | OPTI_TYPE_PRECOMPUTE_INIT
7088 | OPTI_TYPE_PRECOMPUTE_MERKLE
7089 | OPTI_TYPE_EARLY_SKIP
7090 | OPTI_TYPE_NOT_ITERATED
7091 | OPTI_TYPE_APPENDED_SALT
7092 | OPTI_TYPE_RAW_HASH;
7093 dgst_pos0 = 3;
7094 dgst_pos1 = 4;
7095 dgst_pos2 = 2;
7096 dgst_pos3 = 1;
7097 break;
7098
7099 case 132: hash_type = HASH_TYPE_SHA1;
7100 salt_type = SALT_TYPE_EMBEDDED;
7101 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7102 opts_type = OPTS_TYPE_PT_GENERATE_BE
7103 | OPTS_TYPE_PT_UNICODE
7104 | OPTS_TYPE_ST_ADD80
7105 | OPTS_TYPE_ST_ADDBITS15
7106 | OPTS_TYPE_ST_HEX;
7107 kern_type = KERN_TYPE_SHA1_PWUSLT;
7108 dgst_size = DGST_SIZE_4_5;
7109 parse_func = mssql2005_parse_hash;
7110 sort_by_digest = sort_by_digest_4_5;
7111 opti_type = OPTI_TYPE_ZERO_BYTE
7112 | OPTI_TYPE_PRECOMPUTE_INIT
7113 | OPTI_TYPE_PRECOMPUTE_MERKLE
7114 | OPTI_TYPE_EARLY_SKIP
7115 | OPTI_TYPE_NOT_ITERATED
7116 | OPTI_TYPE_APPENDED_SALT
7117 | OPTI_TYPE_RAW_HASH;
7118 dgst_pos0 = 3;
7119 dgst_pos1 = 4;
7120 dgst_pos2 = 2;
7121 dgst_pos3 = 1;
7122 break;
7123
7124 case 133: hash_type = HASH_TYPE_SHA1;
7125 salt_type = SALT_TYPE_EMBEDDED;
7126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7127 opts_type = OPTS_TYPE_PT_GENERATE_BE
7128 | OPTS_TYPE_PT_UNICODE
7129 | OPTS_TYPE_ST_ADD80
7130 | OPTS_TYPE_ST_ADDBITS15;
7131 kern_type = KERN_TYPE_SHA1_PWUSLT;
7132 dgst_size = DGST_SIZE_4_5;
7133 parse_func = peoplesoft_parse_hash;
7134 sort_by_digest = sort_by_digest_4_5;
7135 opti_type = OPTI_TYPE_ZERO_BYTE
7136 | OPTI_TYPE_PRECOMPUTE_INIT
7137 | OPTI_TYPE_PRECOMPUTE_MERKLE
7138 | OPTI_TYPE_EARLY_SKIP
7139 | OPTI_TYPE_NOT_ITERATED
7140 | OPTI_TYPE_APPENDED_SALT
7141 | OPTI_TYPE_RAW_HASH;
7142 dgst_pos0 = 3;
7143 dgst_pos1 = 4;
7144 dgst_pos2 = 2;
7145 dgst_pos3 = 1;
7146 break;
7147
7148 case 140: hash_type = HASH_TYPE_SHA1;
7149 salt_type = SALT_TYPE_INTERN;
7150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7151 opts_type = OPTS_TYPE_PT_GENERATE_BE
7152 | OPTS_TYPE_PT_ADD80
7153 | OPTS_TYPE_PT_ADDBITS15
7154 | OPTS_TYPE_PT_UNICODE;
7155 kern_type = KERN_TYPE_SHA1_SLTPWU;
7156 dgst_size = DGST_SIZE_4_5;
7157 parse_func = sha1s_parse_hash;
7158 sort_by_digest = sort_by_digest_4_5;
7159 opti_type = OPTI_TYPE_ZERO_BYTE
7160 | OPTI_TYPE_PRECOMPUTE_INIT
7161 | OPTI_TYPE_PRECOMPUTE_MERKLE
7162 | OPTI_TYPE_EARLY_SKIP
7163 | OPTI_TYPE_NOT_ITERATED
7164 | OPTI_TYPE_PREPENDED_SALT
7165 | OPTI_TYPE_RAW_HASH;
7166 dgst_pos0 = 3;
7167 dgst_pos1 = 4;
7168 dgst_pos2 = 2;
7169 dgst_pos3 = 1;
7170 break;
7171
7172 case 141: hash_type = HASH_TYPE_SHA1;
7173 salt_type = SALT_TYPE_EMBEDDED;
7174 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7175 opts_type = OPTS_TYPE_PT_GENERATE_BE
7176 | OPTS_TYPE_PT_ADD80
7177 | OPTS_TYPE_PT_ADDBITS15
7178 | OPTS_TYPE_PT_UNICODE
7179 | OPTS_TYPE_ST_BASE64;
7180 kern_type = KERN_TYPE_SHA1_SLTPWU;
7181 dgst_size = DGST_SIZE_4_5;
7182 parse_func = episerver_parse_hash;
7183 sort_by_digest = sort_by_digest_4_5;
7184 opti_type = OPTI_TYPE_ZERO_BYTE
7185 | OPTI_TYPE_PRECOMPUTE_INIT
7186 | OPTI_TYPE_PRECOMPUTE_MERKLE
7187 | OPTI_TYPE_EARLY_SKIP
7188 | OPTI_TYPE_NOT_ITERATED
7189 | OPTI_TYPE_PREPENDED_SALT
7190 | OPTI_TYPE_RAW_HASH;
7191 dgst_pos0 = 3;
7192 dgst_pos1 = 4;
7193 dgst_pos2 = 2;
7194 dgst_pos3 = 1;
7195 break;
7196
7197 case 150: hash_type = HASH_TYPE_SHA1;
7198 salt_type = SALT_TYPE_INTERN;
7199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7200 opts_type = OPTS_TYPE_PT_GENERATE_BE
7201 | OPTS_TYPE_ST_ADD80
7202 | OPTS_TYPE_ST_ADDBITS15;
7203 kern_type = KERN_TYPE_HMACSHA1_PW;
7204 dgst_size = DGST_SIZE_4_5;
7205 parse_func = hmacsha1_parse_hash;
7206 sort_by_digest = sort_by_digest_4_5;
7207 opti_type = OPTI_TYPE_ZERO_BYTE
7208 | OPTI_TYPE_NOT_ITERATED;
7209 dgst_pos0 = 3;
7210 dgst_pos1 = 4;
7211 dgst_pos2 = 2;
7212 dgst_pos3 = 1;
7213 break;
7214
7215 case 160: hash_type = HASH_TYPE_SHA1;
7216 salt_type = SALT_TYPE_INTERN;
7217 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7218 opts_type = OPTS_TYPE_PT_GENERATE_BE
7219 | OPTS_TYPE_PT_ADD80
7220 | OPTS_TYPE_PT_ADDBITS15;
7221 kern_type = KERN_TYPE_HMACSHA1_SLT;
7222 dgst_size = DGST_SIZE_4_5;
7223 parse_func = hmacsha1_parse_hash;
7224 sort_by_digest = sort_by_digest_4_5;
7225 opti_type = OPTI_TYPE_ZERO_BYTE
7226 | OPTI_TYPE_NOT_ITERATED;
7227 dgst_pos0 = 3;
7228 dgst_pos1 = 4;
7229 dgst_pos2 = 2;
7230 dgst_pos3 = 1;
7231 break;
7232
7233 case 190: hash_type = HASH_TYPE_SHA1;
7234 salt_type = SALT_TYPE_NONE;
7235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7236 opts_type = OPTS_TYPE_PT_GENERATE_BE
7237 | OPTS_TYPE_PT_ADD80
7238 | OPTS_TYPE_PT_ADDBITS15;
7239 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7240 dgst_size = DGST_SIZE_4_5;
7241 parse_func = sha1linkedin_parse_hash;
7242 sort_by_digest = sort_by_digest_4_5;
7243 opti_type = OPTI_TYPE_ZERO_BYTE
7244 | OPTI_TYPE_PRECOMPUTE_INIT
7245 | OPTI_TYPE_EARLY_SKIP
7246 | OPTI_TYPE_NOT_ITERATED
7247 | OPTI_TYPE_NOT_SALTED;
7248 dgst_pos0 = 0;
7249 dgst_pos1 = 4;
7250 dgst_pos2 = 3;
7251 dgst_pos3 = 2;
7252 break;
7253
7254 case 200: hash_type = HASH_TYPE_MYSQL;
7255 salt_type = SALT_TYPE_NONE;
7256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7257 opts_type = 0;
7258 kern_type = KERN_TYPE_MYSQL;
7259 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7260 parse_func = mysql323_parse_hash;
7261 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7262 opti_type = OPTI_TYPE_ZERO_BYTE;
7263 dgst_pos0 = 0;
7264 dgst_pos1 = 1;
7265 dgst_pos2 = 2;
7266 dgst_pos3 = 3;
7267 break;
7268
7269 case 300: hash_type = HASH_TYPE_SHA1;
7270 salt_type = SALT_TYPE_NONE;
7271 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7272 opts_type = OPTS_TYPE_PT_GENERATE_BE
7273 | OPTS_TYPE_PT_ADD80
7274 | OPTS_TYPE_PT_ADDBITS15;
7275 kern_type = KERN_TYPE_MYSQL41;
7276 dgst_size = DGST_SIZE_4_5;
7277 parse_func = sha1_parse_hash;
7278 sort_by_digest = sort_by_digest_4_5;
7279 opti_type = OPTI_TYPE_ZERO_BYTE
7280 | OPTI_TYPE_PRECOMPUTE_INIT
7281 | OPTI_TYPE_PRECOMPUTE_MERKLE
7282 | OPTI_TYPE_EARLY_SKIP
7283 | OPTI_TYPE_NOT_ITERATED
7284 | OPTI_TYPE_NOT_SALTED;
7285 dgst_pos0 = 3;
7286 dgst_pos1 = 4;
7287 dgst_pos2 = 2;
7288 dgst_pos3 = 1;
7289 break;
7290
7291 case 400: 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 kern_type = KERN_TYPE_PHPASS;
7296 dgst_size = DGST_SIZE_4_4;
7297 parse_func = phpass_parse_hash;
7298 sort_by_digest = sort_by_digest_4_4;
7299 opti_type = OPTI_TYPE_ZERO_BYTE;
7300 dgst_pos0 = 0;
7301 dgst_pos1 = 1;
7302 dgst_pos2 = 2;
7303 dgst_pos3 = 3;
7304 break;
7305
7306 case 500: hash_type = HASH_TYPE_MD5;
7307 salt_type = SALT_TYPE_EMBEDDED;
7308 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7309 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7310 kern_type = KERN_TYPE_MD5CRYPT;
7311 dgst_size = DGST_SIZE_4_4;
7312 parse_func = md5crypt_parse_hash;
7313 sort_by_digest = sort_by_digest_4_4;
7314 opti_type = OPTI_TYPE_ZERO_BYTE;
7315 dgst_pos0 = 0;
7316 dgst_pos1 = 1;
7317 dgst_pos2 = 2;
7318 dgst_pos3 = 3;
7319 break;
7320
7321 case 501: hash_type = HASH_TYPE_MD5;
7322 salt_type = SALT_TYPE_EMBEDDED;
7323 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7324 opts_type = OPTS_TYPE_PT_GENERATE_LE
7325 | OPTS_TYPE_HASH_COPY;
7326 kern_type = KERN_TYPE_MD5CRYPT;
7327 dgst_size = DGST_SIZE_4_4;
7328 parse_func = juniper_parse_hash;
7329 sort_by_digest = sort_by_digest_4_4;
7330 opti_type = OPTI_TYPE_ZERO_BYTE;
7331 dgst_pos0 = 0;
7332 dgst_pos1 = 1;
7333 dgst_pos2 = 2;
7334 dgst_pos3 = 3;
7335 break;
7336
7337 case 900: hash_type = HASH_TYPE_MD4;
7338 salt_type = SALT_TYPE_NONE;
7339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7340 opts_type = OPTS_TYPE_PT_GENERATE_LE
7341 | OPTS_TYPE_PT_ADD80
7342 | OPTS_TYPE_PT_ADDBITS14;
7343 kern_type = KERN_TYPE_MD4;
7344 dgst_size = DGST_SIZE_4_4;
7345 parse_func = md4_parse_hash;
7346 sort_by_digest = sort_by_digest_4_4;
7347 opti_type = OPTI_TYPE_ZERO_BYTE
7348 | OPTI_TYPE_PRECOMPUTE_INIT
7349 | OPTI_TYPE_PRECOMPUTE_MERKLE
7350 | OPTI_TYPE_MEET_IN_MIDDLE
7351 | OPTI_TYPE_EARLY_SKIP
7352 | OPTI_TYPE_NOT_ITERATED
7353 | OPTI_TYPE_NOT_SALTED
7354 | OPTI_TYPE_RAW_HASH;
7355 dgst_pos0 = 0;
7356 dgst_pos1 = 3;
7357 dgst_pos2 = 2;
7358 dgst_pos3 = 1;
7359 break;
7360
7361 case 1000: hash_type = HASH_TYPE_MD4;
7362 salt_type = SALT_TYPE_NONE;
7363 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7364 opts_type = OPTS_TYPE_PT_GENERATE_LE
7365 | OPTS_TYPE_PT_ADD80
7366 | OPTS_TYPE_PT_ADDBITS14
7367 | OPTS_TYPE_PT_UNICODE;
7368 kern_type = KERN_TYPE_MD4_PWU;
7369 dgst_size = DGST_SIZE_4_4;
7370 parse_func = md4_parse_hash;
7371 sort_by_digest = sort_by_digest_4_4;
7372 opti_type = OPTI_TYPE_ZERO_BYTE
7373 | OPTI_TYPE_PRECOMPUTE_INIT
7374 | OPTI_TYPE_PRECOMPUTE_MERKLE
7375 | OPTI_TYPE_MEET_IN_MIDDLE
7376 | OPTI_TYPE_EARLY_SKIP
7377 | OPTI_TYPE_NOT_ITERATED
7378 | OPTI_TYPE_NOT_SALTED
7379 | OPTI_TYPE_RAW_HASH;
7380 dgst_pos0 = 0;
7381 dgst_pos1 = 3;
7382 dgst_pos2 = 2;
7383 dgst_pos3 = 1;
7384 break;
7385
7386 case 1100: hash_type = HASH_TYPE_MD4;
7387 salt_type = SALT_TYPE_INTERN;
7388 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7389 opts_type = OPTS_TYPE_PT_GENERATE_LE
7390 | OPTS_TYPE_PT_ADD80
7391 | OPTS_TYPE_PT_ADDBITS14
7392 | OPTS_TYPE_PT_UNICODE
7393 | OPTS_TYPE_ST_ADD80
7394 | OPTS_TYPE_ST_UNICODE
7395 | OPTS_TYPE_ST_LOWER;
7396 kern_type = KERN_TYPE_MD44_PWUSLT;
7397 dgst_size = DGST_SIZE_4_4;
7398 parse_func = dcc_parse_hash;
7399 sort_by_digest = sort_by_digest_4_4;
7400 opti_type = OPTI_TYPE_ZERO_BYTE
7401 | OPTI_TYPE_PRECOMPUTE_INIT
7402 | OPTI_TYPE_PRECOMPUTE_MERKLE
7403 | OPTI_TYPE_EARLY_SKIP
7404 | OPTI_TYPE_NOT_ITERATED;
7405 dgst_pos0 = 0;
7406 dgst_pos1 = 3;
7407 dgst_pos2 = 2;
7408 dgst_pos3 = 1;
7409 break;
7410
7411 case 1400: hash_type = HASH_TYPE_SHA256;
7412 salt_type = SALT_TYPE_NONE;
7413 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7414 opts_type = OPTS_TYPE_PT_GENERATE_BE
7415 | OPTS_TYPE_PT_ADD80
7416 | OPTS_TYPE_PT_ADDBITS15;
7417 kern_type = KERN_TYPE_SHA256;
7418 dgst_size = DGST_SIZE_4_8;
7419 parse_func = sha256_parse_hash;
7420 sort_by_digest = sort_by_digest_4_8;
7421 opti_type = OPTI_TYPE_ZERO_BYTE
7422 | OPTI_TYPE_PRECOMPUTE_INIT
7423 | OPTI_TYPE_PRECOMPUTE_MERKLE
7424 | OPTI_TYPE_EARLY_SKIP
7425 | OPTI_TYPE_NOT_ITERATED
7426 | OPTI_TYPE_NOT_SALTED
7427 | OPTI_TYPE_RAW_HASH;
7428 dgst_pos0 = 3;
7429 dgst_pos1 = 7;
7430 dgst_pos2 = 2;
7431 dgst_pos3 = 6;
7432 break;
7433
7434 case 1410: hash_type = HASH_TYPE_SHA256;
7435 salt_type = SALT_TYPE_INTERN;
7436 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7437 opts_type = OPTS_TYPE_PT_GENERATE_BE
7438 | OPTS_TYPE_ST_ADD80
7439 | OPTS_TYPE_ST_ADDBITS15;
7440 kern_type = KERN_TYPE_SHA256_PWSLT;
7441 dgst_size = DGST_SIZE_4_8;
7442 parse_func = sha256s_parse_hash;
7443 sort_by_digest = sort_by_digest_4_8;
7444 opti_type = OPTI_TYPE_ZERO_BYTE
7445 | OPTI_TYPE_PRECOMPUTE_INIT
7446 | OPTI_TYPE_PRECOMPUTE_MERKLE
7447 | OPTI_TYPE_EARLY_SKIP
7448 | OPTI_TYPE_NOT_ITERATED
7449 | OPTI_TYPE_APPENDED_SALT
7450 | OPTI_TYPE_RAW_HASH;
7451 dgst_pos0 = 3;
7452 dgst_pos1 = 7;
7453 dgst_pos2 = 2;
7454 dgst_pos3 = 6;
7455 break;
7456
7457 case 1420: hash_type = HASH_TYPE_SHA256;
7458 salt_type = SALT_TYPE_INTERN;
7459 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7460 opts_type = OPTS_TYPE_PT_GENERATE_BE
7461 | OPTS_TYPE_PT_ADD80
7462 | OPTS_TYPE_PT_ADDBITS15;
7463 kern_type = KERN_TYPE_SHA256_SLTPW;
7464 dgst_size = DGST_SIZE_4_8;
7465 parse_func = sha256s_parse_hash;
7466 sort_by_digest = sort_by_digest_4_8;
7467 opti_type = OPTI_TYPE_ZERO_BYTE
7468 | OPTI_TYPE_PRECOMPUTE_INIT
7469 | OPTI_TYPE_PRECOMPUTE_MERKLE
7470 | OPTI_TYPE_EARLY_SKIP
7471 | OPTI_TYPE_NOT_ITERATED
7472 | OPTI_TYPE_PREPENDED_SALT
7473 | OPTI_TYPE_RAW_HASH;
7474 dgst_pos0 = 3;
7475 dgst_pos1 = 7;
7476 dgst_pos2 = 2;
7477 dgst_pos3 = 6;
7478 break;
7479
7480 case 1421: hash_type = HASH_TYPE_SHA256;
7481 salt_type = SALT_TYPE_EMBEDDED;
7482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7483 opts_type = OPTS_TYPE_PT_GENERATE_BE
7484 | OPTS_TYPE_PT_ADD80
7485 | OPTS_TYPE_PT_ADDBITS15;
7486 kern_type = KERN_TYPE_SHA256_SLTPW;
7487 dgst_size = DGST_SIZE_4_8;
7488 parse_func = hmailserver_parse_hash;
7489 sort_by_digest = sort_by_digest_4_8;
7490 opti_type = OPTI_TYPE_ZERO_BYTE
7491 | OPTI_TYPE_PRECOMPUTE_INIT
7492 | OPTI_TYPE_PRECOMPUTE_MERKLE
7493 | OPTI_TYPE_EARLY_SKIP
7494 | OPTI_TYPE_NOT_ITERATED
7495 | OPTI_TYPE_PREPENDED_SALT
7496 | OPTI_TYPE_RAW_HASH;
7497 dgst_pos0 = 3;
7498 dgst_pos1 = 7;
7499 dgst_pos2 = 2;
7500 dgst_pos3 = 6;
7501 break;
7502
7503 case 1430: hash_type = HASH_TYPE_SHA256;
7504 salt_type = SALT_TYPE_INTERN;
7505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7506 opts_type = OPTS_TYPE_PT_GENERATE_BE
7507 | OPTS_TYPE_PT_UNICODE
7508 | OPTS_TYPE_ST_ADD80
7509 | OPTS_TYPE_ST_ADDBITS15;
7510 kern_type = KERN_TYPE_SHA256_PWUSLT;
7511 dgst_size = DGST_SIZE_4_8;
7512 parse_func = sha256s_parse_hash;
7513 sort_by_digest = sort_by_digest_4_8;
7514 opti_type = OPTI_TYPE_ZERO_BYTE
7515 | OPTI_TYPE_PRECOMPUTE_INIT
7516 | OPTI_TYPE_PRECOMPUTE_MERKLE
7517 | OPTI_TYPE_EARLY_SKIP
7518 | OPTI_TYPE_NOT_ITERATED
7519 | OPTI_TYPE_APPENDED_SALT
7520 | OPTI_TYPE_RAW_HASH;
7521 dgst_pos0 = 3;
7522 dgst_pos1 = 7;
7523 dgst_pos2 = 2;
7524 dgst_pos3 = 6;
7525 break;
7526
7527 case 1440: hash_type = HASH_TYPE_SHA256;
7528 salt_type = SALT_TYPE_INTERN;
7529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7530 opts_type = OPTS_TYPE_PT_GENERATE_BE
7531 | OPTS_TYPE_PT_ADD80
7532 | OPTS_TYPE_PT_ADDBITS15
7533 | OPTS_TYPE_PT_UNICODE;
7534 kern_type = KERN_TYPE_SHA256_SLTPWU;
7535 dgst_size = DGST_SIZE_4_8;
7536 parse_func = sha256s_parse_hash;
7537 sort_by_digest = sort_by_digest_4_8;
7538 opti_type = OPTI_TYPE_ZERO_BYTE
7539 | OPTI_TYPE_PRECOMPUTE_INIT
7540 | OPTI_TYPE_PRECOMPUTE_MERKLE
7541 | OPTI_TYPE_EARLY_SKIP
7542 | OPTI_TYPE_NOT_ITERATED
7543 | OPTI_TYPE_PREPENDED_SALT
7544 | OPTI_TYPE_RAW_HASH;
7545 dgst_pos0 = 3;
7546 dgst_pos1 = 7;
7547 dgst_pos2 = 2;
7548 dgst_pos3 = 6;
7549 break;
7550
7551 case 1441: hash_type = HASH_TYPE_SHA256;
7552 salt_type = SALT_TYPE_EMBEDDED;
7553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7554 opts_type = OPTS_TYPE_PT_GENERATE_BE
7555 | OPTS_TYPE_PT_ADD80
7556 | OPTS_TYPE_PT_ADDBITS15
7557 | OPTS_TYPE_PT_UNICODE
7558 | OPTS_TYPE_ST_BASE64;
7559 kern_type = KERN_TYPE_SHA256_SLTPWU;
7560 dgst_size = DGST_SIZE_4_8;
7561 parse_func = episerver4_parse_hash;
7562 sort_by_digest = sort_by_digest_4_8;
7563 opti_type = OPTI_TYPE_ZERO_BYTE
7564 | OPTI_TYPE_PRECOMPUTE_INIT
7565 | OPTI_TYPE_PRECOMPUTE_MERKLE
7566 | OPTI_TYPE_EARLY_SKIP
7567 | OPTI_TYPE_NOT_ITERATED
7568 | OPTI_TYPE_PREPENDED_SALT
7569 | OPTI_TYPE_RAW_HASH;
7570 dgst_pos0 = 3;
7571 dgst_pos1 = 7;
7572 dgst_pos2 = 2;
7573 dgst_pos3 = 6;
7574 break;
7575
7576 case 1450: hash_type = HASH_TYPE_SHA256;
7577 salt_type = SALT_TYPE_INTERN;
7578 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7579 opts_type = OPTS_TYPE_PT_GENERATE_BE
7580 | OPTS_TYPE_ST_ADD80;
7581 kern_type = KERN_TYPE_HMACSHA256_PW;
7582 dgst_size = DGST_SIZE_4_8;
7583 parse_func = hmacsha256_parse_hash;
7584 sort_by_digest = sort_by_digest_4_8;
7585 opti_type = OPTI_TYPE_ZERO_BYTE
7586 | OPTI_TYPE_NOT_ITERATED;
7587 dgst_pos0 = 3;
7588 dgst_pos1 = 7;
7589 dgst_pos2 = 2;
7590 dgst_pos3 = 6;
7591 break;
7592
7593 case 1460: hash_type = HASH_TYPE_SHA256;
7594 salt_type = SALT_TYPE_INTERN;
7595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7596 opts_type = OPTS_TYPE_PT_GENERATE_BE
7597 | OPTS_TYPE_PT_ADD80
7598 | OPTS_TYPE_PT_ADDBITS15;
7599 kern_type = KERN_TYPE_HMACSHA256_SLT;
7600 dgst_size = DGST_SIZE_4_8;
7601 parse_func = hmacsha256_parse_hash;
7602 sort_by_digest = sort_by_digest_4_8;
7603 opti_type = OPTI_TYPE_ZERO_BYTE
7604 | OPTI_TYPE_NOT_ITERATED;
7605 dgst_pos0 = 3;
7606 dgst_pos1 = 7;
7607 dgst_pos2 = 2;
7608 dgst_pos3 = 6;
7609 break;
7610
7611 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7612 salt_type = SALT_TYPE_EMBEDDED;
7613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7614 opts_type = OPTS_TYPE_PT_GENERATE_LE
7615 | OPTS_TYPE_PT_BITSLICE;
7616 kern_type = KERN_TYPE_DESCRYPT;
7617 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7618 parse_func = descrypt_parse_hash;
7619 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7620 opti_type = OPTI_TYPE_ZERO_BYTE
7621 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7622 dgst_pos0 = 0;
7623 dgst_pos1 = 1;
7624 dgst_pos2 = 2;
7625 dgst_pos3 = 3;
7626 break;
7627
7628 case 1600: hash_type = HASH_TYPE_MD5;
7629 salt_type = SALT_TYPE_EMBEDDED;
7630 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7631 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7632 kern_type = KERN_TYPE_APR1CRYPT;
7633 dgst_size = DGST_SIZE_4_4;
7634 parse_func = md5apr1_parse_hash;
7635 sort_by_digest = sort_by_digest_4_4;
7636 opti_type = OPTI_TYPE_ZERO_BYTE;
7637 dgst_pos0 = 0;
7638 dgst_pos1 = 1;
7639 dgst_pos2 = 2;
7640 dgst_pos3 = 3;
7641 break;
7642
7643 case 1700: hash_type = HASH_TYPE_SHA512;
7644 salt_type = SALT_TYPE_NONE;
7645 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7646 opts_type = OPTS_TYPE_PT_GENERATE_BE
7647 | OPTS_TYPE_PT_ADD80
7648 | OPTS_TYPE_PT_ADDBITS15;
7649 kern_type = KERN_TYPE_SHA512;
7650 dgst_size = DGST_SIZE_8_8;
7651 parse_func = sha512_parse_hash;
7652 sort_by_digest = sort_by_digest_8_8;
7653 opti_type = OPTI_TYPE_ZERO_BYTE
7654 | OPTI_TYPE_PRECOMPUTE_INIT
7655 | OPTI_TYPE_PRECOMPUTE_MERKLE
7656 | OPTI_TYPE_EARLY_SKIP
7657 | OPTI_TYPE_NOT_ITERATED
7658 | OPTI_TYPE_NOT_SALTED
7659 | OPTI_TYPE_RAW_HASH;
7660 dgst_pos0 = 14;
7661 dgst_pos1 = 15;
7662 dgst_pos2 = 6;
7663 dgst_pos3 = 7;
7664 break;
7665
7666 case 1710: hash_type = HASH_TYPE_SHA512;
7667 salt_type = SALT_TYPE_INTERN;
7668 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7669 opts_type = OPTS_TYPE_PT_GENERATE_BE
7670 | OPTS_TYPE_ST_ADD80
7671 | OPTS_TYPE_ST_ADDBITS15;
7672 kern_type = KERN_TYPE_SHA512_PWSLT;
7673 dgst_size = DGST_SIZE_8_8;
7674 parse_func = sha512s_parse_hash;
7675 sort_by_digest = sort_by_digest_8_8;
7676 opti_type = OPTI_TYPE_ZERO_BYTE
7677 | OPTI_TYPE_PRECOMPUTE_INIT
7678 | OPTI_TYPE_PRECOMPUTE_MERKLE
7679 | OPTI_TYPE_EARLY_SKIP
7680 | OPTI_TYPE_NOT_ITERATED
7681 | OPTI_TYPE_APPENDED_SALT
7682 | OPTI_TYPE_RAW_HASH;
7683 dgst_pos0 = 14;
7684 dgst_pos1 = 15;
7685 dgst_pos2 = 6;
7686 dgst_pos3 = 7;
7687 break;
7688
7689 case 1711: hash_type = HASH_TYPE_SHA512;
7690 salt_type = SALT_TYPE_EMBEDDED;
7691 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7692 opts_type = OPTS_TYPE_PT_GENERATE_BE
7693 | OPTS_TYPE_ST_ADD80
7694 | OPTS_TYPE_ST_ADDBITS15;
7695 kern_type = KERN_TYPE_SHA512_PWSLT;
7696 dgst_size = DGST_SIZE_8_8;
7697 parse_func = sha512b64s_parse_hash;
7698 sort_by_digest = sort_by_digest_8_8;
7699 opti_type = OPTI_TYPE_ZERO_BYTE
7700 | OPTI_TYPE_PRECOMPUTE_INIT
7701 | OPTI_TYPE_PRECOMPUTE_MERKLE
7702 | OPTI_TYPE_EARLY_SKIP
7703 | OPTI_TYPE_NOT_ITERATED
7704 | OPTI_TYPE_APPENDED_SALT
7705 | OPTI_TYPE_RAW_HASH;
7706 dgst_pos0 = 14;
7707 dgst_pos1 = 15;
7708 dgst_pos2 = 6;
7709 dgst_pos3 = 7;
7710 break;
7711
7712 case 1720: hash_type = HASH_TYPE_SHA512;
7713 salt_type = SALT_TYPE_INTERN;
7714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7715 opts_type = OPTS_TYPE_PT_GENERATE_BE
7716 | OPTS_TYPE_PT_ADD80
7717 | OPTS_TYPE_PT_ADDBITS15;
7718 kern_type = KERN_TYPE_SHA512_SLTPW;
7719 dgst_size = DGST_SIZE_8_8;
7720 parse_func = sha512s_parse_hash;
7721 sort_by_digest = sort_by_digest_8_8;
7722 opti_type = OPTI_TYPE_ZERO_BYTE
7723 | OPTI_TYPE_PRECOMPUTE_INIT
7724 | OPTI_TYPE_PRECOMPUTE_MERKLE
7725 | OPTI_TYPE_EARLY_SKIP
7726 | OPTI_TYPE_NOT_ITERATED
7727 | OPTI_TYPE_PREPENDED_SALT
7728 | OPTI_TYPE_RAW_HASH;
7729 dgst_pos0 = 14;
7730 dgst_pos1 = 15;
7731 dgst_pos2 = 6;
7732 dgst_pos3 = 7;
7733 break;
7734
7735 case 1722: hash_type = HASH_TYPE_SHA512;
7736 salt_type = SALT_TYPE_EMBEDDED;
7737 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7738 opts_type = OPTS_TYPE_PT_GENERATE_BE
7739 | OPTS_TYPE_PT_ADD80
7740 | OPTS_TYPE_PT_ADDBITS15
7741 | OPTS_TYPE_ST_HEX;
7742 kern_type = KERN_TYPE_SHA512_SLTPW;
7743 dgst_size = DGST_SIZE_8_8;
7744 parse_func = osx512_parse_hash;
7745 sort_by_digest = sort_by_digest_8_8;
7746 opti_type = OPTI_TYPE_ZERO_BYTE
7747 | OPTI_TYPE_PRECOMPUTE_INIT
7748 | OPTI_TYPE_PRECOMPUTE_MERKLE
7749 | OPTI_TYPE_EARLY_SKIP
7750 | OPTI_TYPE_NOT_ITERATED
7751 | OPTI_TYPE_PREPENDED_SALT
7752 | OPTI_TYPE_RAW_HASH;
7753 dgst_pos0 = 14;
7754 dgst_pos1 = 15;
7755 dgst_pos2 = 6;
7756 dgst_pos3 = 7;
7757 break;
7758
7759 case 1730: hash_type = HASH_TYPE_SHA512;
7760 salt_type = SALT_TYPE_INTERN;
7761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7762 opts_type = OPTS_TYPE_PT_GENERATE_BE
7763 | OPTS_TYPE_PT_UNICODE
7764 | OPTS_TYPE_ST_ADD80
7765 | OPTS_TYPE_ST_ADDBITS15;
7766 kern_type = KERN_TYPE_SHA512_PWSLTU;
7767 dgst_size = DGST_SIZE_8_8;
7768 parse_func = sha512s_parse_hash;
7769 sort_by_digest = sort_by_digest_8_8;
7770 opti_type = OPTI_TYPE_ZERO_BYTE
7771 | OPTI_TYPE_PRECOMPUTE_INIT
7772 | OPTI_TYPE_PRECOMPUTE_MERKLE
7773 | OPTI_TYPE_EARLY_SKIP
7774 | OPTI_TYPE_NOT_ITERATED
7775 | OPTI_TYPE_APPENDED_SALT
7776 | OPTI_TYPE_RAW_HASH;
7777 dgst_pos0 = 14;
7778 dgst_pos1 = 15;
7779 dgst_pos2 = 6;
7780 dgst_pos3 = 7;
7781 break;
7782
7783 case 1731: hash_type = HASH_TYPE_SHA512;
7784 salt_type = SALT_TYPE_EMBEDDED;
7785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7786 opts_type = OPTS_TYPE_PT_GENERATE_BE
7787 | OPTS_TYPE_PT_UNICODE
7788 | OPTS_TYPE_ST_ADD80
7789 | OPTS_TYPE_ST_ADDBITS15
7790 | OPTS_TYPE_ST_HEX;
7791 kern_type = KERN_TYPE_SHA512_PWSLTU;
7792 dgst_size = DGST_SIZE_8_8;
7793 parse_func = mssql2012_parse_hash;
7794 sort_by_digest = sort_by_digest_8_8;
7795 opti_type = OPTI_TYPE_ZERO_BYTE
7796 | OPTI_TYPE_PRECOMPUTE_INIT
7797 | OPTI_TYPE_PRECOMPUTE_MERKLE
7798 | OPTI_TYPE_EARLY_SKIP
7799 | OPTI_TYPE_NOT_ITERATED
7800 | OPTI_TYPE_APPENDED_SALT
7801 | OPTI_TYPE_RAW_HASH;
7802 dgst_pos0 = 14;
7803 dgst_pos1 = 15;
7804 dgst_pos2 = 6;
7805 dgst_pos3 = 7;
7806 break;
7807
7808 case 1740: hash_type = HASH_TYPE_SHA512;
7809 salt_type = SALT_TYPE_INTERN;
7810 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7811 opts_type = OPTS_TYPE_PT_GENERATE_BE
7812 | OPTS_TYPE_PT_ADD80
7813 | OPTS_TYPE_PT_ADDBITS15
7814 | OPTS_TYPE_PT_UNICODE;
7815 kern_type = KERN_TYPE_SHA512_SLTPWU;
7816 dgst_size = DGST_SIZE_8_8;
7817 parse_func = sha512s_parse_hash;
7818 sort_by_digest = sort_by_digest_8_8;
7819 opti_type = OPTI_TYPE_ZERO_BYTE
7820 | OPTI_TYPE_PRECOMPUTE_INIT
7821 | OPTI_TYPE_PRECOMPUTE_MERKLE
7822 | OPTI_TYPE_EARLY_SKIP
7823 | OPTI_TYPE_NOT_ITERATED
7824 | OPTI_TYPE_PREPENDED_SALT
7825 | OPTI_TYPE_RAW_HASH;
7826 dgst_pos0 = 14;
7827 dgst_pos1 = 15;
7828 dgst_pos2 = 6;
7829 dgst_pos3 = 7;
7830 break;
7831
7832 case 1750: hash_type = HASH_TYPE_SHA512;
7833 salt_type = SALT_TYPE_INTERN;
7834 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7835 opts_type = OPTS_TYPE_PT_GENERATE_BE
7836 | OPTS_TYPE_ST_ADD80;
7837 kern_type = KERN_TYPE_HMACSHA512_PW;
7838 dgst_size = DGST_SIZE_8_8;
7839 parse_func = hmacsha512_parse_hash;
7840 sort_by_digest = sort_by_digest_8_8;
7841 opti_type = OPTI_TYPE_ZERO_BYTE
7842 | OPTI_TYPE_NOT_ITERATED;
7843 dgst_pos0 = 14;
7844 dgst_pos1 = 15;
7845 dgst_pos2 = 6;
7846 dgst_pos3 = 7;
7847 break;
7848
7849 case 1760: hash_type = HASH_TYPE_SHA512;
7850 salt_type = SALT_TYPE_INTERN;
7851 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7852 opts_type = OPTS_TYPE_PT_GENERATE_BE
7853 | OPTS_TYPE_PT_ADD80
7854 | OPTS_TYPE_PT_ADDBITS15;
7855 kern_type = KERN_TYPE_HMACSHA512_SLT;
7856 dgst_size = DGST_SIZE_8_8;
7857 parse_func = hmacsha512_parse_hash;
7858 sort_by_digest = sort_by_digest_8_8;
7859 opti_type = OPTI_TYPE_ZERO_BYTE
7860 | OPTI_TYPE_NOT_ITERATED;
7861 dgst_pos0 = 14;
7862 dgst_pos1 = 15;
7863 dgst_pos2 = 6;
7864 dgst_pos3 = 7;
7865 break;
7866
7867 case 1800: hash_type = HASH_TYPE_SHA512;
7868 salt_type = SALT_TYPE_EMBEDDED;
7869 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7870 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7871 kern_type = KERN_TYPE_SHA512CRYPT;
7872 dgst_size = DGST_SIZE_8_8;
7873 parse_func = sha512crypt_parse_hash;
7874 sort_by_digest = sort_by_digest_8_8;
7875 opti_type = OPTI_TYPE_ZERO_BYTE;
7876 dgst_pos0 = 0;
7877 dgst_pos1 = 1;
7878 dgst_pos2 = 2;
7879 dgst_pos3 = 3;
7880 break;
7881
7882 case 2100: hash_type = HASH_TYPE_DCC2;
7883 salt_type = SALT_TYPE_EMBEDDED;
7884 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7885 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7886 | OPTS_TYPE_ST_LOWER
7887 | OPTS_TYPE_ST_UNICODE;
7888 kern_type = KERN_TYPE_DCC2;
7889 dgst_size = DGST_SIZE_4_4;
7890 parse_func = dcc2_parse_hash;
7891 sort_by_digest = sort_by_digest_4_4;
7892 opti_type = OPTI_TYPE_ZERO_BYTE;
7893 dgst_pos0 = 0;
7894 dgst_pos1 = 1;
7895 dgst_pos2 = 2;
7896 dgst_pos3 = 3;
7897 break;
7898
7899 case 2400: hash_type = HASH_TYPE_MD5;
7900 salt_type = SALT_TYPE_NONE;
7901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7902 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7903 kern_type = KERN_TYPE_MD5PIX;
7904 dgst_size = DGST_SIZE_4_4;
7905 parse_func = md5pix_parse_hash;
7906 sort_by_digest = sort_by_digest_4_4;
7907 opti_type = OPTI_TYPE_ZERO_BYTE
7908 | OPTI_TYPE_PRECOMPUTE_INIT
7909 | OPTI_TYPE_PRECOMPUTE_MERKLE
7910 | OPTI_TYPE_EARLY_SKIP
7911 | OPTI_TYPE_NOT_ITERATED
7912 | OPTI_TYPE_NOT_SALTED;
7913 dgst_pos0 = 0;
7914 dgst_pos1 = 3;
7915 dgst_pos2 = 2;
7916 dgst_pos3 = 1;
7917 break;
7918
7919 case 2410: hash_type = HASH_TYPE_MD5;
7920 salt_type = SALT_TYPE_INTERN;
7921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7922 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7923 kern_type = KERN_TYPE_MD5ASA;
7924 dgst_size = DGST_SIZE_4_4;
7925 parse_func = md5asa_parse_hash;
7926 sort_by_digest = sort_by_digest_4_4;
7927 opti_type = OPTI_TYPE_ZERO_BYTE
7928 | OPTI_TYPE_PRECOMPUTE_INIT
7929 | OPTI_TYPE_PRECOMPUTE_MERKLE
7930 | OPTI_TYPE_EARLY_SKIP
7931 | OPTI_TYPE_NOT_ITERATED;
7932 dgst_pos0 = 0;
7933 dgst_pos1 = 3;
7934 dgst_pos2 = 2;
7935 dgst_pos3 = 1;
7936 break;
7937
7938 case 2500: hash_type = HASH_TYPE_WPA;
7939 salt_type = SALT_TYPE_EMBEDDED;
7940 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7941 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7942 kern_type = KERN_TYPE_WPA;
7943 dgst_size = DGST_SIZE_4_4;
7944 parse_func = wpa_parse_hash;
7945 sort_by_digest = sort_by_digest_4_4;
7946 opti_type = OPTI_TYPE_ZERO_BYTE;
7947 dgst_pos0 = 0;
7948 dgst_pos1 = 1;
7949 dgst_pos2 = 2;
7950 dgst_pos3 = 3;
7951 break;
7952
7953 case 2600: hash_type = HASH_TYPE_MD5;
7954 salt_type = SALT_TYPE_VIRTUAL;
7955 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7956 opts_type = OPTS_TYPE_PT_GENERATE_LE
7957 | OPTS_TYPE_PT_ADD80
7958 | OPTS_TYPE_PT_ADDBITS14
7959 | OPTS_TYPE_ST_ADD80;
7960 kern_type = KERN_TYPE_MD55_PWSLT1;
7961 dgst_size = DGST_SIZE_4_4;
7962 parse_func = md5md5_parse_hash;
7963 sort_by_digest = sort_by_digest_4_4;
7964 opti_type = OPTI_TYPE_ZERO_BYTE
7965 | OPTI_TYPE_PRECOMPUTE_INIT
7966 | OPTI_TYPE_PRECOMPUTE_MERKLE
7967 | OPTI_TYPE_EARLY_SKIP;
7968 dgst_pos0 = 0;
7969 dgst_pos1 = 3;
7970 dgst_pos2 = 2;
7971 dgst_pos3 = 1;
7972 break;
7973
7974 case 2611: hash_type = HASH_TYPE_MD5;
7975 salt_type = SALT_TYPE_INTERN;
7976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7977 opts_type = OPTS_TYPE_PT_GENERATE_LE
7978 | OPTS_TYPE_PT_ADD80
7979 | OPTS_TYPE_PT_ADDBITS14
7980 | OPTS_TYPE_ST_ADD80;
7981 kern_type = KERN_TYPE_MD55_PWSLT1;
7982 dgst_size = DGST_SIZE_4_4;
7983 parse_func = vb3_parse_hash;
7984 sort_by_digest = sort_by_digest_4_4;
7985 opti_type = OPTI_TYPE_ZERO_BYTE
7986 | OPTI_TYPE_PRECOMPUTE_INIT
7987 | OPTI_TYPE_PRECOMPUTE_MERKLE
7988 | OPTI_TYPE_EARLY_SKIP;
7989 dgst_pos0 = 0;
7990 dgst_pos1 = 3;
7991 dgst_pos2 = 2;
7992 dgst_pos3 = 1;
7993 break;
7994
7995 case 2612: hash_type = HASH_TYPE_MD5;
7996 salt_type = SALT_TYPE_EMBEDDED;
7997 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7998 opts_type = OPTS_TYPE_PT_GENERATE_LE
7999 | OPTS_TYPE_PT_ADD80
8000 | OPTS_TYPE_PT_ADDBITS14
8001 | OPTS_TYPE_ST_ADD80
8002 | OPTS_TYPE_ST_HEX;
8003 kern_type = KERN_TYPE_MD55_PWSLT1;
8004 dgst_size = DGST_SIZE_4_4;
8005 parse_func = phps_parse_hash;
8006 sort_by_digest = sort_by_digest_4_4;
8007 opti_type = OPTI_TYPE_ZERO_BYTE
8008 | OPTI_TYPE_PRECOMPUTE_INIT
8009 | OPTI_TYPE_PRECOMPUTE_MERKLE
8010 | OPTI_TYPE_EARLY_SKIP;
8011 dgst_pos0 = 0;
8012 dgst_pos1 = 3;
8013 dgst_pos2 = 2;
8014 dgst_pos3 = 1;
8015 break;
8016
8017 case 2711: hash_type = HASH_TYPE_MD5;
8018 salt_type = SALT_TYPE_INTERN;
8019 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8020 opts_type = OPTS_TYPE_PT_GENERATE_LE
8021 | OPTS_TYPE_PT_ADD80
8022 | OPTS_TYPE_PT_ADDBITS14
8023 | OPTS_TYPE_ST_ADD80;
8024 kern_type = KERN_TYPE_MD55_PWSLT2;
8025 dgst_size = DGST_SIZE_4_4;
8026 parse_func = vb30_parse_hash;
8027 sort_by_digest = sort_by_digest_4_4;
8028 opti_type = OPTI_TYPE_ZERO_BYTE
8029 | OPTI_TYPE_PRECOMPUTE_INIT
8030 | OPTI_TYPE_EARLY_SKIP;
8031 dgst_pos0 = 0;
8032 dgst_pos1 = 3;
8033 dgst_pos2 = 2;
8034 dgst_pos3 = 1;
8035 break;
8036
8037 case 2811: hash_type = HASH_TYPE_MD5;
8038 salt_type = SALT_TYPE_INTERN;
8039 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8040 opts_type = OPTS_TYPE_PT_GENERATE_LE
8041 | OPTS_TYPE_PT_ADD80
8042 | OPTS_TYPE_PT_ADDBITS14;
8043 kern_type = KERN_TYPE_MD55_SLTPW;
8044 dgst_size = DGST_SIZE_4_4;
8045 parse_func = ipb2_parse_hash;
8046 sort_by_digest = sort_by_digest_4_4;
8047 opti_type = OPTI_TYPE_ZERO_BYTE
8048 | OPTI_TYPE_PRECOMPUTE_INIT
8049 | OPTI_TYPE_EARLY_SKIP;
8050 dgst_pos0 = 0;
8051 dgst_pos1 = 3;
8052 dgst_pos2 = 2;
8053 dgst_pos3 = 1;
8054 break;
8055
8056 case 3000: hash_type = HASH_TYPE_LM;
8057 salt_type = SALT_TYPE_NONE;
8058 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8059 opts_type = OPTS_TYPE_PT_GENERATE_LE
8060 | OPTS_TYPE_PT_UPPER
8061 | OPTS_TYPE_PT_BITSLICE;
8062 kern_type = KERN_TYPE_LM;
8063 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8064 parse_func = lm_parse_hash;
8065 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8066 opti_type = OPTI_TYPE_ZERO_BYTE
8067 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8068 dgst_pos0 = 0;
8069 dgst_pos1 = 1;
8070 dgst_pos2 = 2;
8071 dgst_pos3 = 3;
8072 break;
8073
8074 case 3100: hash_type = HASH_TYPE_ORACLEH;
8075 salt_type = SALT_TYPE_INTERN;
8076 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8077 opts_type = OPTS_TYPE_PT_GENERATE_LE
8078 | OPTS_TYPE_PT_UPPER
8079 | OPTS_TYPE_ST_UPPER;
8080 kern_type = KERN_TYPE_ORACLEH;
8081 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8082 parse_func = oracleh_parse_hash;
8083 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8084 opti_type = OPTI_TYPE_ZERO_BYTE;
8085 dgst_pos0 = 0;
8086 dgst_pos1 = 1;
8087 dgst_pos2 = 2;
8088 dgst_pos3 = 3;
8089 break;
8090
8091 case 3200: hash_type = HASH_TYPE_BCRYPT;
8092 salt_type = SALT_TYPE_EMBEDDED;
8093 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8094 opts_type = OPTS_TYPE_PT_GENERATE_LE
8095 | OPTS_TYPE_ST_GENERATE_LE;
8096 kern_type = KERN_TYPE_BCRYPT;
8097 dgst_size = DGST_SIZE_4_6;
8098 parse_func = bcrypt_parse_hash;
8099 sort_by_digest = sort_by_digest_4_6;
8100 opti_type = OPTI_TYPE_ZERO_BYTE;
8101 dgst_pos0 = 0;
8102 dgst_pos1 = 1;
8103 dgst_pos2 = 2;
8104 dgst_pos3 = 3;
8105 break;
8106
8107 case 3710: hash_type = HASH_TYPE_MD5;
8108 salt_type = SALT_TYPE_INTERN;
8109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8110 opts_type = OPTS_TYPE_PT_GENERATE_LE
8111 | OPTS_TYPE_PT_ADD80
8112 | OPTS_TYPE_PT_ADDBITS14;
8113 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8114 dgst_size = DGST_SIZE_4_4;
8115 parse_func = md5s_parse_hash;
8116 sort_by_digest = sort_by_digest_4_4;
8117 opti_type = OPTI_TYPE_ZERO_BYTE
8118 | OPTI_TYPE_PRECOMPUTE_INIT
8119 | OPTI_TYPE_PRECOMPUTE_MERKLE
8120 | OPTI_TYPE_EARLY_SKIP;
8121 dgst_pos0 = 0;
8122 dgst_pos1 = 3;
8123 dgst_pos2 = 2;
8124 dgst_pos3 = 1;
8125 break;
8126
8127 case 3711: hash_type = HASH_TYPE_MD5;
8128 salt_type = SALT_TYPE_EMBEDDED;
8129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8130 opts_type = OPTS_TYPE_PT_GENERATE_LE
8131 | OPTS_TYPE_PT_ADD80
8132 | OPTS_TYPE_PT_ADDBITS14;
8133 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8134 dgst_size = DGST_SIZE_4_4;
8135 parse_func = mediawiki_b_parse_hash;
8136 sort_by_digest = sort_by_digest_4_4;
8137 opti_type = OPTI_TYPE_ZERO_BYTE
8138 | OPTI_TYPE_PRECOMPUTE_INIT
8139 | OPTI_TYPE_PRECOMPUTE_MERKLE
8140 | OPTI_TYPE_EARLY_SKIP;
8141 dgst_pos0 = 0;
8142 dgst_pos1 = 3;
8143 dgst_pos2 = 2;
8144 dgst_pos3 = 1;
8145 break;
8146
8147 case 3800: hash_type = HASH_TYPE_MD5;
8148 salt_type = SALT_TYPE_INTERN;
8149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8150 opts_type = OPTS_TYPE_PT_GENERATE_LE
8151 | OPTS_TYPE_ST_ADDBITS14;
8152 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8153 dgst_size = DGST_SIZE_4_4;
8154 parse_func = md5s_parse_hash;
8155 sort_by_digest = sort_by_digest_4_4;
8156 opti_type = OPTI_TYPE_ZERO_BYTE
8157 | OPTI_TYPE_PRECOMPUTE_INIT
8158 | OPTI_TYPE_PRECOMPUTE_MERKLE
8159 | OPTI_TYPE_EARLY_SKIP
8160 | OPTI_TYPE_NOT_ITERATED
8161 | OPTI_TYPE_RAW_HASH;
8162 dgst_pos0 = 0;
8163 dgst_pos1 = 3;
8164 dgst_pos2 = 2;
8165 dgst_pos3 = 1;
8166 break;
8167
8168 case 4300: hash_type = HASH_TYPE_MD5;
8169 salt_type = SALT_TYPE_VIRTUAL;
8170 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8171 opts_type = OPTS_TYPE_PT_GENERATE_LE
8172 | OPTS_TYPE_PT_ADD80
8173 | OPTS_TYPE_PT_ADDBITS14
8174 | OPTS_TYPE_ST_ADD80;
8175 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8176 dgst_size = DGST_SIZE_4_4;
8177 parse_func = md5md5_parse_hash;
8178 sort_by_digest = sort_by_digest_4_4;
8179 opti_type = OPTI_TYPE_ZERO_BYTE
8180 | OPTI_TYPE_PRECOMPUTE_INIT
8181 | OPTI_TYPE_PRECOMPUTE_MERKLE
8182 | OPTI_TYPE_EARLY_SKIP;
8183 dgst_pos0 = 0;
8184 dgst_pos1 = 3;
8185 dgst_pos2 = 2;
8186 dgst_pos3 = 1;
8187 break;
8188
8189
8190 case 4400: hash_type = HASH_TYPE_MD5;
8191 salt_type = SALT_TYPE_NONE;
8192 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8193 opts_type = OPTS_TYPE_PT_GENERATE_BE
8194 | OPTS_TYPE_PT_ADD80
8195 | OPTS_TYPE_PT_ADDBITS15;
8196 kern_type = KERN_TYPE_MD5_SHA1;
8197 dgst_size = DGST_SIZE_4_4;
8198 parse_func = md5_parse_hash;
8199 sort_by_digest = sort_by_digest_4_4;
8200 opti_type = OPTI_TYPE_ZERO_BYTE
8201 | OPTI_TYPE_PRECOMPUTE_INIT
8202 | OPTI_TYPE_PRECOMPUTE_MERKLE
8203 | OPTI_TYPE_EARLY_SKIP
8204 | OPTI_TYPE_NOT_ITERATED
8205 | OPTI_TYPE_NOT_SALTED
8206 | OPTI_TYPE_RAW_HASH;
8207 dgst_pos0 = 0;
8208 dgst_pos1 = 3;
8209 dgst_pos2 = 2;
8210 dgst_pos3 = 1;
8211 break;
8212
8213 case 4500: hash_type = HASH_TYPE_SHA1;
8214 salt_type = SALT_TYPE_NONE;
8215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8216 opts_type = OPTS_TYPE_PT_GENERATE_BE
8217 | OPTS_TYPE_PT_ADD80
8218 | OPTS_TYPE_PT_ADDBITS15;
8219 kern_type = KERN_TYPE_SHA11;
8220 dgst_size = DGST_SIZE_4_5;
8221 parse_func = sha1_parse_hash;
8222 sort_by_digest = sort_by_digest_4_5;
8223 opti_type = OPTI_TYPE_ZERO_BYTE
8224 | OPTI_TYPE_PRECOMPUTE_INIT
8225 | OPTI_TYPE_PRECOMPUTE_MERKLE
8226 | OPTI_TYPE_EARLY_SKIP
8227 | OPTI_TYPE_NOT_SALTED;
8228 dgst_pos0 = 3;
8229 dgst_pos1 = 4;
8230 dgst_pos2 = 2;
8231 dgst_pos3 = 1;
8232 break;
8233
8234 case 4700: hash_type = HASH_TYPE_SHA1;
8235 salt_type = SALT_TYPE_NONE;
8236 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8237 opts_type = OPTS_TYPE_PT_GENERATE_LE
8238 | OPTS_TYPE_PT_ADD80
8239 | OPTS_TYPE_PT_ADDBITS14;
8240 kern_type = KERN_TYPE_SHA1_MD5;
8241 dgst_size = DGST_SIZE_4_5;
8242 parse_func = sha1_parse_hash;
8243 sort_by_digest = sort_by_digest_4_5;
8244 opti_type = OPTI_TYPE_ZERO_BYTE
8245 | OPTI_TYPE_PRECOMPUTE_INIT
8246 | OPTI_TYPE_PRECOMPUTE_MERKLE
8247 | OPTI_TYPE_EARLY_SKIP
8248 | OPTI_TYPE_NOT_ITERATED
8249 | OPTI_TYPE_NOT_SALTED
8250 | OPTI_TYPE_RAW_HASH;
8251 dgst_pos0 = 3;
8252 dgst_pos1 = 4;
8253 dgst_pos2 = 2;
8254 dgst_pos3 = 1;
8255 break;
8256
8257 case 4800: hash_type = HASH_TYPE_MD5;
8258 salt_type = SALT_TYPE_EMBEDDED;
8259 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8260 opts_type = OPTS_TYPE_PT_GENERATE_LE
8261 | OPTS_TYPE_PT_ADDBITS14;
8262 kern_type = KERN_TYPE_MD5_CHAP;
8263 dgst_size = DGST_SIZE_4_4;
8264 parse_func = chap_parse_hash;
8265 sort_by_digest = sort_by_digest_4_4;
8266 opti_type = OPTI_TYPE_ZERO_BYTE
8267 | OPTI_TYPE_PRECOMPUTE_INIT
8268 | OPTI_TYPE_PRECOMPUTE_MERKLE
8269 | OPTI_TYPE_MEET_IN_MIDDLE
8270 | OPTI_TYPE_EARLY_SKIP
8271 | OPTI_TYPE_NOT_ITERATED
8272 | OPTI_TYPE_RAW_HASH;
8273 dgst_pos0 = 0;
8274 dgst_pos1 = 3;
8275 dgst_pos2 = 2;
8276 dgst_pos3 = 1;
8277 break;
8278
8279 case 4900: hash_type = HASH_TYPE_SHA1;
8280 salt_type = SALT_TYPE_INTERN;
8281 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8282 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8283 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8284 dgst_size = DGST_SIZE_4_5;
8285 parse_func = sha1s_parse_hash;
8286 sort_by_digest = sort_by_digest_4_5;
8287 opti_type = OPTI_TYPE_ZERO_BYTE
8288 | OPTI_TYPE_PRECOMPUTE_INIT
8289 | OPTI_TYPE_PRECOMPUTE_MERKLE
8290 | OPTI_TYPE_EARLY_SKIP;
8291 dgst_pos0 = 3;
8292 dgst_pos1 = 4;
8293 dgst_pos2 = 2;
8294 dgst_pos3 = 1;
8295 break;
8296
8297 case 5000: hash_type = HASH_TYPE_KECCAK;
8298 salt_type = SALT_TYPE_EMBEDDED;
8299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8300 opts_type = OPTS_TYPE_PT_GENERATE_LE
8301 | OPTS_TYPE_PT_ADD01;
8302 kern_type = KERN_TYPE_KECCAK;
8303 dgst_size = DGST_SIZE_8_25;
8304 parse_func = keccak_parse_hash;
8305 sort_by_digest = sort_by_digest_8_25;
8306 opti_type = OPTI_TYPE_ZERO_BYTE
8307 | OPTI_TYPE_RAW_HASH;
8308 dgst_pos0 = 2;
8309 dgst_pos1 = 3;
8310 dgst_pos2 = 4;
8311 dgst_pos3 = 5;
8312 break;
8313
8314 case 5100: hash_type = HASH_TYPE_MD5H;
8315 salt_type = SALT_TYPE_NONE;
8316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8317 opts_type = OPTS_TYPE_PT_GENERATE_LE
8318 | OPTS_TYPE_PT_ADD80
8319 | OPTS_TYPE_PT_ADDBITS14;
8320 kern_type = KERN_TYPE_MD5H;
8321 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8322 parse_func = md5half_parse_hash;
8323 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8324 opti_type = OPTI_TYPE_ZERO_BYTE
8325 | OPTI_TYPE_RAW_HASH;
8326 dgst_pos0 = 0;
8327 dgst_pos1 = 1;
8328 dgst_pos2 = 2;
8329 dgst_pos3 = 3;
8330 break;
8331
8332 case 5200: hash_type = HASH_TYPE_SHA256;
8333 salt_type = SALT_TYPE_EMBEDDED;
8334 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8335 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8336 kern_type = KERN_TYPE_PSAFE3;
8337 dgst_size = DGST_SIZE_4_8;
8338 parse_func = psafe3_parse_hash;
8339 sort_by_digest = sort_by_digest_4_8;
8340 opti_type = OPTI_TYPE_ZERO_BYTE;
8341 dgst_pos0 = 0;
8342 dgst_pos1 = 1;
8343 dgst_pos2 = 2;
8344 dgst_pos3 = 3;
8345 break;
8346
8347 case 5300: hash_type = HASH_TYPE_MD5;
8348 salt_type = SALT_TYPE_EMBEDDED;
8349 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8350 opts_type = OPTS_TYPE_PT_GENERATE_LE
8351 | OPTS_TYPE_ST_ADD80;
8352 kern_type = KERN_TYPE_IKEPSK_MD5;
8353 dgst_size = DGST_SIZE_4_4;
8354 parse_func = ikepsk_md5_parse_hash;
8355 sort_by_digest = sort_by_digest_4_4;
8356 opti_type = OPTI_TYPE_ZERO_BYTE;
8357 dgst_pos0 = 0;
8358 dgst_pos1 = 3;
8359 dgst_pos2 = 2;
8360 dgst_pos3 = 1;
8361 break;
8362
8363 case 5400: hash_type = HASH_TYPE_SHA1;
8364 salt_type = SALT_TYPE_EMBEDDED;
8365 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8366 opts_type = OPTS_TYPE_PT_GENERATE_BE
8367 | OPTS_TYPE_ST_ADD80;
8368 kern_type = KERN_TYPE_IKEPSK_SHA1;
8369 dgst_size = DGST_SIZE_4_5;
8370 parse_func = ikepsk_sha1_parse_hash;
8371 sort_by_digest = sort_by_digest_4_5;
8372 opti_type = OPTI_TYPE_ZERO_BYTE;
8373 dgst_pos0 = 3;
8374 dgst_pos1 = 4;
8375 dgst_pos2 = 2;
8376 dgst_pos3 = 1;
8377 break;
8378
8379 case 5500: hash_type = HASH_TYPE_NETNTLM;
8380 salt_type = SALT_TYPE_EMBEDDED;
8381 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8382 opts_type = OPTS_TYPE_PT_GENERATE_LE
8383 | OPTS_TYPE_PT_ADD80
8384 | OPTS_TYPE_PT_ADDBITS14
8385 | OPTS_TYPE_PT_UNICODE
8386 | OPTS_TYPE_ST_HEX;
8387 kern_type = KERN_TYPE_NETNTLMv1;
8388 dgst_size = DGST_SIZE_4_4;
8389 parse_func = netntlmv1_parse_hash;
8390 sort_by_digest = sort_by_digest_4_4;
8391 opti_type = OPTI_TYPE_ZERO_BYTE
8392 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8393 dgst_pos0 = 0;
8394 dgst_pos1 = 1;
8395 dgst_pos2 = 2;
8396 dgst_pos3 = 3;
8397 break;
8398
8399 case 5600: hash_type = HASH_TYPE_MD5;
8400 salt_type = SALT_TYPE_EMBEDDED;
8401 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8402 opts_type = OPTS_TYPE_PT_GENERATE_LE
8403 | OPTS_TYPE_PT_ADD80
8404 | OPTS_TYPE_PT_ADDBITS14
8405 | OPTS_TYPE_PT_UNICODE;
8406 kern_type = KERN_TYPE_NETNTLMv2;
8407 dgst_size = DGST_SIZE_4_4;
8408 parse_func = netntlmv2_parse_hash;
8409 sort_by_digest = sort_by_digest_4_4;
8410 opti_type = OPTI_TYPE_ZERO_BYTE;
8411 dgst_pos0 = 0;
8412 dgst_pos1 = 3;
8413 dgst_pos2 = 2;
8414 dgst_pos3 = 1;
8415 break;
8416
8417 case 5700: hash_type = HASH_TYPE_SHA256;
8418 salt_type = SALT_TYPE_NONE;
8419 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8420 opts_type = OPTS_TYPE_PT_GENERATE_BE
8421 | OPTS_TYPE_PT_ADD80
8422 | OPTS_TYPE_PT_ADDBITS15;
8423 kern_type = KERN_TYPE_SHA256;
8424 dgst_size = DGST_SIZE_4_8;
8425 parse_func = cisco4_parse_hash;
8426 sort_by_digest = sort_by_digest_4_8;
8427 opti_type = OPTI_TYPE_ZERO_BYTE
8428 | OPTI_TYPE_PRECOMPUTE_INIT
8429 | OPTI_TYPE_PRECOMPUTE_MERKLE
8430 | OPTI_TYPE_EARLY_SKIP
8431 | OPTI_TYPE_NOT_ITERATED
8432 | OPTI_TYPE_NOT_SALTED
8433 | OPTI_TYPE_RAW_HASH;
8434 dgst_pos0 = 3;
8435 dgst_pos1 = 7;
8436 dgst_pos2 = 2;
8437 dgst_pos3 = 6;
8438 break;
8439
8440 case 5800: hash_type = HASH_TYPE_SHA1;
8441 salt_type = SALT_TYPE_INTERN;
8442 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8443 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8444 | OPTS_TYPE_ST_ADD80;
8445 kern_type = KERN_TYPE_ANDROIDPIN;
8446 dgst_size = DGST_SIZE_4_5;
8447 parse_func = androidpin_parse_hash;
8448 sort_by_digest = sort_by_digest_4_5;
8449 opti_type = OPTI_TYPE_ZERO_BYTE;
8450 dgst_pos0 = 0;
8451 dgst_pos1 = 1;
8452 dgst_pos2 = 2;
8453 dgst_pos3 = 3;
8454 break;
8455
8456 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8457 salt_type = SALT_TYPE_NONE;
8458 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8459 opts_type = OPTS_TYPE_PT_GENERATE_LE
8460 | OPTS_TYPE_PT_ADD80;
8461 kern_type = KERN_TYPE_RIPEMD160;
8462 dgst_size = DGST_SIZE_4_5;
8463 parse_func = ripemd160_parse_hash;
8464 sort_by_digest = sort_by_digest_4_5;
8465 opti_type = OPTI_TYPE_ZERO_BYTE;
8466 dgst_pos0 = 0;
8467 dgst_pos1 = 1;
8468 dgst_pos2 = 2;
8469 dgst_pos3 = 3;
8470 break;
8471
8472 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8473 salt_type = SALT_TYPE_NONE;
8474 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8475 opts_type = OPTS_TYPE_PT_GENERATE_BE
8476 | OPTS_TYPE_PT_ADD80;
8477 kern_type = KERN_TYPE_WHIRLPOOL;
8478 dgst_size = DGST_SIZE_4_16;
8479 parse_func = whirlpool_parse_hash;
8480 sort_by_digest = sort_by_digest_4_16;
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 6211: 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_XTS512;
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 6212: hash_type = HASH_TYPE_RIPEMD160;
8504 salt_type = SALT_TYPE_EMBEDDED;
8505 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8506 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8507 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8508 dgst_size = DGST_SIZE_4_5;
8509 parse_func = truecrypt_parse_hash_2k;
8510 sort_by_digest = sort_by_digest_4_5;
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 6213: hash_type = HASH_TYPE_RIPEMD160;
8519 salt_type = SALT_TYPE_EMBEDDED;
8520 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8521 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8522 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8523 dgst_size = DGST_SIZE_4_5;
8524 parse_func = truecrypt_parse_hash_2k;
8525 sort_by_digest = sort_by_digest_4_5;
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 6221: 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_XTS512;
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 6222: hash_type = HASH_TYPE_SHA512;
8549 salt_type = SALT_TYPE_EMBEDDED;
8550 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8551 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8552 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8553 dgst_size = DGST_SIZE_8_8;
8554 parse_func = truecrypt_parse_hash_1k;
8555 sort_by_digest = sort_by_digest_8_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 6223: hash_type = HASH_TYPE_SHA512;
8564 salt_type = SALT_TYPE_EMBEDDED;
8565 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8566 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8567 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8568 dgst_size = DGST_SIZE_8_8;
8569 parse_func = truecrypt_parse_hash_1k;
8570 sort_by_digest = sort_by_digest_8_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 6231: 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_XTS512;
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 6232: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1024;
8598 dgst_size = DGST_SIZE_4_8;
8599 parse_func = truecrypt_parse_hash_1k;
8600 sort_by_digest = sort_by_digest_4_8;
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 6233: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1536;
8613 dgst_size = DGST_SIZE_4_8;
8614 parse_func = truecrypt_parse_hash_1k;
8615 sort_by_digest = sort_by_digest_4_8;
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 6241: 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_XTS512;
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 6242: hash_type = HASH_TYPE_RIPEMD160;
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_TCRIPEMD160_XTS1024;
8643 dgst_size = DGST_SIZE_4_5;
8644 parse_func = truecrypt_parse_hash_1k;
8645 sort_by_digest = sort_by_digest_4_5;
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 6243: hash_type = HASH_TYPE_RIPEMD160;
8654 salt_type = SALT_TYPE_EMBEDDED;
8655 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8656 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8657 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8658 dgst_size = DGST_SIZE_4_5;
8659 parse_func = truecrypt_parse_hash_1k;
8660 sort_by_digest = sort_by_digest_4_5;
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 6300: hash_type = HASH_TYPE_MD5;
8669 salt_type = SALT_TYPE_EMBEDDED;
8670 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8671 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8672 kern_type = KERN_TYPE_MD5AIX;
8673 dgst_size = DGST_SIZE_4_4;
8674 parse_func = md5aix_parse_hash;
8675 sort_by_digest = sort_by_digest_4_4;
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 6400: hash_type = HASH_TYPE_SHA256;
8684 salt_type = SALT_TYPE_EMBEDDED;
8685 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8686 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8687 kern_type = KERN_TYPE_SHA256AIX;
8688 dgst_size = DGST_SIZE_4_8;
8689 parse_func = sha256aix_parse_hash;
8690 sort_by_digest = sort_by_digest_4_8;
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 6500: hash_type = HASH_TYPE_SHA512;
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_SHA512AIX;
8703 dgst_size = DGST_SIZE_8_8;
8704 parse_func = sha512aix_parse_hash;
8705 sort_by_digest = sort_by_digest_8_8;
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 6600: 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_AGILEKEY;
8718 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8719 parse_func = agilekey_parse_hash;
8720 sort_by_digest = sort_by_digest_4_5;
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 6700: hash_type = HASH_TYPE_SHA1;
8729 salt_type = SALT_TYPE_EMBEDDED;
8730 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8731 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8732 kern_type = KERN_TYPE_SHA1AIX;
8733 dgst_size = DGST_SIZE_4_5;
8734 parse_func = sha1aix_parse_hash;
8735 sort_by_digest = sort_by_digest_4_5;
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 6800: hash_type = HASH_TYPE_AES;
8744 salt_type = SALT_TYPE_EMBEDDED;
8745 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8746 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8747 kern_type = KERN_TYPE_LASTPASS;
8748 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8749 parse_func = lastpass_parse_hash;
8750 sort_by_digest = sort_by_digest_4_8;
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 6900: hash_type = HASH_TYPE_GOST;
8759 salt_type = SALT_TYPE_NONE;
8760 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8761 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8762 kern_type = KERN_TYPE_GOST;
8763 dgst_size = DGST_SIZE_4_8;
8764 parse_func = gost_parse_hash;
8765 sort_by_digest = sort_by_digest_4_8;
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 7100: hash_type = HASH_TYPE_SHA512;
8774 salt_type = SALT_TYPE_EMBEDDED;
8775 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8776 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8777 kern_type = KERN_TYPE_PBKDF2_SHA512;
8778 dgst_size = DGST_SIZE_8_16;
8779 parse_func = sha512osx_parse_hash;
8780 sort_by_digest = sort_by_digest_8_16;
8781 opti_type = OPTI_TYPE_ZERO_BYTE;
8782 dgst_pos0 = 0;
8783 dgst_pos1 = 1;
8784 dgst_pos2 = 2;
8785 dgst_pos3 = 3;
8786 break;
8787
8788 case 7200: hash_type = HASH_TYPE_SHA512;
8789 salt_type = SALT_TYPE_EMBEDDED;
8790 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8791 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8792 kern_type = KERN_TYPE_PBKDF2_SHA512;
8793 dgst_size = DGST_SIZE_8_16;
8794 parse_func = sha512grub_parse_hash;
8795 sort_by_digest = sort_by_digest_8_16;
8796 opti_type = OPTI_TYPE_ZERO_BYTE;
8797 dgst_pos0 = 0;
8798 dgst_pos1 = 1;
8799 dgst_pos2 = 2;
8800 dgst_pos3 = 3;
8801 break;
8802
8803 case 7300: hash_type = HASH_TYPE_SHA1;
8804 salt_type = SALT_TYPE_EMBEDDED;
8805 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8806 opts_type = OPTS_TYPE_PT_GENERATE_BE
8807 | OPTS_TYPE_ST_ADD80
8808 | OPTS_TYPE_ST_ADDBITS15;
8809 kern_type = KERN_TYPE_RAKP;
8810 dgst_size = DGST_SIZE_4_5;
8811 parse_func = rakp_parse_hash;
8812 sort_by_digest = sort_by_digest_4_5;
8813 opti_type = OPTI_TYPE_ZERO_BYTE
8814 | OPTI_TYPE_NOT_ITERATED;
8815 dgst_pos0 = 3;
8816 dgst_pos1 = 4;
8817 dgst_pos2 = 2;
8818 dgst_pos3 = 1;
8819 break;
8820
8821 case 7400: hash_type = HASH_TYPE_SHA256;
8822 salt_type = SALT_TYPE_EMBEDDED;
8823 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8824 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8825 kern_type = KERN_TYPE_SHA256CRYPT;
8826 dgst_size = DGST_SIZE_4_8;
8827 parse_func = sha256crypt_parse_hash;
8828 sort_by_digest = sort_by_digest_4_8;
8829 opti_type = OPTI_TYPE_ZERO_BYTE;
8830 dgst_pos0 = 0;
8831 dgst_pos1 = 1;
8832 dgst_pos2 = 2;
8833 dgst_pos3 = 3;
8834 break;
8835
8836 case 7500: hash_type = HASH_TYPE_KRB5PA;
8837 salt_type = SALT_TYPE_EMBEDDED;
8838 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8839 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8840 kern_type = KERN_TYPE_KRB5PA;
8841 dgst_size = DGST_SIZE_4_4;
8842 parse_func = krb5pa_parse_hash;
8843 sort_by_digest = sort_by_digest_4_4;
8844 opti_type = OPTI_TYPE_ZERO_BYTE
8845 | OPTI_TYPE_NOT_ITERATED;
8846 dgst_pos0 = 0;
8847 dgst_pos1 = 1;
8848 dgst_pos2 = 2;
8849 dgst_pos3 = 3;
8850 break;
8851
8852 case 7600: hash_type = HASH_TYPE_SHA1;
8853 salt_type = SALT_TYPE_INTERN;
8854 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8855 opts_type = OPTS_TYPE_PT_GENERATE_BE
8856 | OPTS_TYPE_PT_ADD80
8857 | OPTS_TYPE_PT_ADDBITS15;
8858 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8859 dgst_size = DGST_SIZE_4_5;
8860 parse_func = redmine_parse_hash;
8861 sort_by_digest = sort_by_digest_4_5;
8862 opti_type = OPTI_TYPE_ZERO_BYTE
8863 | OPTI_TYPE_PRECOMPUTE_INIT
8864 | OPTI_TYPE_EARLY_SKIP
8865 | OPTI_TYPE_NOT_ITERATED
8866 | OPTI_TYPE_PREPENDED_SALT;
8867 dgst_pos0 = 3;
8868 dgst_pos1 = 4;
8869 dgst_pos2 = 2;
8870 dgst_pos3 = 1;
8871 break;
8872
8873 case 7700: hash_type = HASH_TYPE_SAPB;
8874 salt_type = SALT_TYPE_EMBEDDED;
8875 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8876 opts_type = OPTS_TYPE_PT_GENERATE_LE
8877 | OPTS_TYPE_PT_UPPER
8878 | OPTS_TYPE_ST_UPPER;
8879 kern_type = KERN_TYPE_SAPB;
8880 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8881 parse_func = sapb_parse_hash;
8882 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8883 opti_type = OPTI_TYPE_ZERO_BYTE
8884 | OPTI_TYPE_PRECOMPUTE_INIT
8885 | OPTI_TYPE_NOT_ITERATED;
8886 dgst_pos0 = 0;
8887 dgst_pos1 = 1;
8888 dgst_pos2 = 2;
8889 dgst_pos3 = 3;
8890 break;
8891
8892 case 7800: hash_type = HASH_TYPE_SAPG;
8893 salt_type = SALT_TYPE_EMBEDDED;
8894 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8895 opts_type = OPTS_TYPE_PT_GENERATE_BE
8896 | OPTS_TYPE_ST_ADD80
8897 | OPTS_TYPE_ST_UPPER;
8898 kern_type = KERN_TYPE_SAPG;
8899 dgst_size = DGST_SIZE_4_5;
8900 parse_func = sapg_parse_hash;
8901 sort_by_digest = sort_by_digest_4_5;
8902 opti_type = OPTI_TYPE_ZERO_BYTE
8903 | OPTI_TYPE_PRECOMPUTE_INIT
8904 | OPTI_TYPE_NOT_ITERATED;
8905 dgst_pos0 = 3;
8906 dgst_pos1 = 4;
8907 dgst_pos2 = 2;
8908 dgst_pos3 = 1;
8909 break;
8910
8911 case 7900: hash_type = HASH_TYPE_SHA512;
8912 salt_type = SALT_TYPE_EMBEDDED;
8913 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8914 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8915 kern_type = KERN_TYPE_DRUPAL7;
8916 dgst_size = DGST_SIZE_8_8;
8917 parse_func = drupal7_parse_hash;
8918 sort_by_digest = sort_by_digest_8_8;
8919 opti_type = OPTI_TYPE_ZERO_BYTE;
8920 dgst_pos0 = 0;
8921 dgst_pos1 = 1;
8922 dgst_pos2 = 2;
8923 dgst_pos3 = 3;
8924 break;
8925
8926 case 8000: hash_type = HASH_TYPE_SHA256;
8927 salt_type = SALT_TYPE_EMBEDDED;
8928 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8929 opts_type = OPTS_TYPE_PT_GENERATE_BE
8930 | OPTS_TYPE_PT_UNICODE
8931 | OPTS_TYPE_ST_ADD80
8932 | OPTS_TYPE_ST_HEX;
8933 kern_type = KERN_TYPE_SYBASEASE;
8934 dgst_size = DGST_SIZE_4_8;
8935 parse_func = sybasease_parse_hash;
8936 sort_by_digest = sort_by_digest_4_8;
8937 opti_type = OPTI_TYPE_ZERO_BYTE
8938 | OPTI_TYPE_PRECOMPUTE_INIT
8939 | OPTI_TYPE_EARLY_SKIP
8940 | OPTI_TYPE_NOT_ITERATED
8941 | OPTI_TYPE_RAW_HASH;
8942 dgst_pos0 = 3;
8943 dgst_pos1 = 7;
8944 dgst_pos2 = 2;
8945 dgst_pos3 = 6;
8946 break;
8947
8948 case 8100: hash_type = HASH_TYPE_SHA1;
8949 salt_type = SALT_TYPE_EMBEDDED;
8950 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8951 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8952 kern_type = KERN_TYPE_NETSCALER;
8953 dgst_size = DGST_SIZE_4_5;
8954 parse_func = netscaler_parse_hash;
8955 sort_by_digest = sort_by_digest_4_5;
8956 opti_type = OPTI_TYPE_ZERO_BYTE
8957 | OPTI_TYPE_PRECOMPUTE_INIT
8958 | OPTI_TYPE_PRECOMPUTE_MERKLE
8959 | OPTI_TYPE_EARLY_SKIP
8960 | OPTI_TYPE_NOT_ITERATED
8961 | OPTI_TYPE_PREPENDED_SALT
8962 | OPTI_TYPE_RAW_HASH;
8963 dgst_pos0 = 3;
8964 dgst_pos1 = 4;
8965 dgst_pos2 = 2;
8966 dgst_pos3 = 1;
8967 break;
8968
8969 case 8200: hash_type = HASH_TYPE_SHA256;
8970 salt_type = SALT_TYPE_EMBEDDED;
8971 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8972 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8973 kern_type = KERN_TYPE_CLOUDKEY;
8974 dgst_size = DGST_SIZE_4_8;
8975 parse_func = cloudkey_parse_hash;
8976 sort_by_digest = sort_by_digest_4_8;
8977 opti_type = OPTI_TYPE_ZERO_BYTE;
8978 dgst_pos0 = 0;
8979 dgst_pos1 = 1;
8980 dgst_pos2 = 2;
8981 dgst_pos3 = 3;
8982 break;
8983
8984 case 8300: hash_type = HASH_TYPE_SHA1;
8985 salt_type = SALT_TYPE_EMBEDDED;
8986 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8987 opts_type = OPTS_TYPE_PT_GENERATE_LE
8988 | OPTS_TYPE_ST_HEX
8989 | OPTS_TYPE_ST_ADD80;
8990 kern_type = KERN_TYPE_NSEC3;
8991 dgst_size = DGST_SIZE_4_5;
8992 parse_func = nsec3_parse_hash;
8993 sort_by_digest = sort_by_digest_4_5;
8994 opti_type = OPTI_TYPE_ZERO_BYTE;
8995 dgst_pos0 = 3;
8996 dgst_pos1 = 4;
8997 dgst_pos2 = 2;
8998 dgst_pos3 = 1;
8999 break;
9000
9001 case 8400: hash_type = HASH_TYPE_SHA1;
9002 salt_type = SALT_TYPE_INTERN;
9003 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9004 opts_type = OPTS_TYPE_PT_GENERATE_BE
9005 | OPTS_TYPE_PT_ADD80
9006 | OPTS_TYPE_PT_ADDBITS15;
9007 kern_type = KERN_TYPE_WBB3;
9008 dgst_size = DGST_SIZE_4_5;
9009 parse_func = wbb3_parse_hash;
9010 sort_by_digest = sort_by_digest_4_5;
9011 opti_type = OPTI_TYPE_ZERO_BYTE
9012 | OPTI_TYPE_PRECOMPUTE_INIT
9013 | OPTI_TYPE_NOT_ITERATED;
9014 dgst_pos0 = 3;
9015 dgst_pos1 = 4;
9016 dgst_pos2 = 2;
9017 dgst_pos3 = 1;
9018 break;
9019
9020 case 8500: hash_type = HASH_TYPE_DESRACF;
9021 salt_type = SALT_TYPE_EMBEDDED;
9022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9023 opts_type = OPTS_TYPE_PT_GENERATE_LE
9024 | OPTS_TYPE_ST_UPPER;
9025 kern_type = KERN_TYPE_RACF;
9026 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9027 parse_func = racf_parse_hash;
9028 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9029 opti_type = OPTI_TYPE_ZERO_BYTE
9030 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9031 dgst_pos0 = 0;
9032 dgst_pos1 = 1;
9033 dgst_pos2 = 2;
9034 dgst_pos3 = 3;
9035 break;
9036
9037 case 8600: hash_type = HASH_TYPE_LOTUS5;
9038 salt_type = SALT_TYPE_NONE;
9039 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9040 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9041 kern_type = KERN_TYPE_LOTUS5;
9042 dgst_size = DGST_SIZE_4_4;
9043 parse_func = lotus5_parse_hash;
9044 sort_by_digest = sort_by_digest_4_4;
9045 opti_type = OPTI_TYPE_EARLY_SKIP
9046 | OPTI_TYPE_NOT_ITERATED
9047 | OPTI_TYPE_NOT_SALTED
9048 | OPTI_TYPE_RAW_HASH;
9049 dgst_pos0 = 0;
9050 dgst_pos1 = 1;
9051 dgst_pos2 = 2;
9052 dgst_pos3 = 3;
9053 break;
9054
9055 case 8700: hash_type = HASH_TYPE_LOTUS6;
9056 salt_type = SALT_TYPE_EMBEDDED;
9057 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9058 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9059 kern_type = KERN_TYPE_LOTUS6;
9060 dgst_size = DGST_SIZE_4_4;
9061 parse_func = lotus6_parse_hash;
9062 sort_by_digest = sort_by_digest_4_4;
9063 opti_type = OPTI_TYPE_EARLY_SKIP
9064 | OPTI_TYPE_NOT_ITERATED
9065 | OPTI_TYPE_RAW_HASH;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 1;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 3;
9070 break;
9071
9072 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9073 salt_type = SALT_TYPE_EMBEDDED;
9074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9075 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9076 kern_type = KERN_TYPE_ANDROIDFDE;
9077 dgst_size = DGST_SIZE_4_4;
9078 parse_func = androidfde_parse_hash;
9079 sort_by_digest = sort_by_digest_4_4;
9080 opti_type = OPTI_TYPE_ZERO_BYTE;
9081 dgst_pos0 = 0;
9082 dgst_pos1 = 1;
9083 dgst_pos2 = 2;
9084 dgst_pos3 = 3;
9085 break;
9086
9087 case 8900: hash_type = HASH_TYPE_SCRYPT;
9088 salt_type = SALT_TYPE_EMBEDDED;
9089 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9090 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9091 kern_type = KERN_TYPE_SCRYPT;
9092 dgst_size = DGST_SIZE_4_8;
9093 parse_func = scrypt_parse_hash;
9094 sort_by_digest = sort_by_digest_4_8;
9095 opti_type = OPTI_TYPE_ZERO_BYTE;
9096 dgst_pos0 = 0;
9097 dgst_pos1 = 1;
9098 dgst_pos2 = 2;
9099 dgst_pos3 = 3;
9100 break;
9101
9102 case 9000: hash_type = HASH_TYPE_SHA1;
9103 salt_type = SALT_TYPE_EMBEDDED;
9104 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9105 opts_type = OPTS_TYPE_PT_GENERATE_LE
9106 | OPTS_TYPE_ST_GENERATE_LE;
9107 kern_type = KERN_TYPE_PSAFE2;
9108 dgst_size = DGST_SIZE_4_5;
9109 parse_func = psafe2_parse_hash;
9110 sort_by_digest = sort_by_digest_4_5;
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 9100: hash_type = HASH_TYPE_LOTUS8;
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_LOTUS8;
9123 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9124 parse_func = lotus8_parse_hash;
9125 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
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 9200: hash_type = HASH_TYPE_SHA256;
9134 salt_type = SALT_TYPE_EMBEDDED;
9135 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9136 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9137 kern_type = KERN_TYPE_PBKDF2_SHA256;
9138 dgst_size = DGST_SIZE_4_32;
9139 parse_func = cisco8_parse_hash;
9140 sort_by_digest = sort_by_digest_4_32;
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 9300: hash_type = HASH_TYPE_SCRYPT;
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_SCRYPT;
9153 dgst_size = DGST_SIZE_4_8;
9154 parse_func = cisco9_parse_hash;
9155 sort_by_digest = sort_by_digest_4_8;
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 9400: hash_type = HASH_TYPE_OFFICE2007;
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_OFFICE2007;
9168 dgst_size = DGST_SIZE_4_4;
9169 parse_func = office2007_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 9500: hash_type = HASH_TYPE_OFFICE2010;
9179 salt_type = SALT_TYPE_EMBEDDED;
9180 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9181 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9182 kern_type = KERN_TYPE_OFFICE2010;
9183 dgst_size = DGST_SIZE_4_4;
9184 parse_func = office2010_parse_hash;
9185 sort_by_digest = sort_by_digest_4_4;
9186 opti_type = OPTI_TYPE_ZERO_BYTE;
9187 dgst_pos0 = 0;
9188 dgst_pos1 = 1;
9189 dgst_pos2 = 2;
9190 dgst_pos3 = 3;
9191 break;
9192
9193 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9194 salt_type = SALT_TYPE_EMBEDDED;
9195 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9196 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9197 kern_type = KERN_TYPE_OFFICE2013;
9198 dgst_size = DGST_SIZE_4_4;
9199 parse_func = office2013_parse_hash;
9200 sort_by_digest = sort_by_digest_4_4;
9201 opti_type = OPTI_TYPE_ZERO_BYTE;
9202 dgst_pos0 = 0;
9203 dgst_pos1 = 1;
9204 dgst_pos2 = 2;
9205 dgst_pos3 = 3;
9206 break;
9207
9208 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9209 salt_type = SALT_TYPE_EMBEDDED;
9210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9211 opts_type = OPTS_TYPE_PT_GENERATE_LE
9212 | OPTS_TYPE_PT_ADD80
9213 | OPTS_TYPE_PT_UNICODE;
9214 kern_type = KERN_TYPE_OLDOFFICE01;
9215 dgst_size = DGST_SIZE_4_4;
9216 parse_func = oldoffice01_parse_hash;
9217 sort_by_digest = sort_by_digest_4_4;
9218 opti_type = OPTI_TYPE_ZERO_BYTE
9219 | OPTI_TYPE_PRECOMPUTE_INIT
9220 | OPTI_TYPE_NOT_ITERATED;
9221 dgst_pos0 = 0;
9222 dgst_pos1 = 1;
9223 dgst_pos2 = 2;
9224 dgst_pos3 = 3;
9225 break;
9226
9227 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9228 salt_type = SALT_TYPE_EMBEDDED;
9229 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9230 opts_type = OPTS_TYPE_PT_GENERATE_LE
9231 | OPTS_TYPE_PT_ADD80;
9232 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9233 dgst_size = DGST_SIZE_4_4;
9234 parse_func = oldoffice01cm1_parse_hash;
9235 sort_by_digest = sort_by_digest_4_4;
9236 opti_type = OPTI_TYPE_ZERO_BYTE
9237 | OPTI_TYPE_PRECOMPUTE_INIT
9238 | OPTI_TYPE_NOT_ITERATED;
9239 dgst_pos0 = 0;
9240 dgst_pos1 = 1;
9241 dgst_pos2 = 2;
9242 dgst_pos3 = 3;
9243 break;
9244
9245 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9246 salt_type = SALT_TYPE_EMBEDDED;
9247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9248 opts_type = OPTS_TYPE_PT_GENERATE_LE
9249 | OPTS_TYPE_PT_ADD80
9250 | OPTS_TYPE_PT_UNICODE
9251 | OPTS_TYPE_PT_NEVERCRACK;
9252 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9253 dgst_size = DGST_SIZE_4_4;
9254 parse_func = oldoffice01cm2_parse_hash;
9255 sort_by_digest = sort_by_digest_4_4;
9256 opti_type = OPTI_TYPE_ZERO_BYTE
9257 | OPTI_TYPE_PRECOMPUTE_INIT
9258 | OPTI_TYPE_NOT_ITERATED;
9259 dgst_pos0 = 0;
9260 dgst_pos1 = 1;
9261 dgst_pos2 = 2;
9262 dgst_pos3 = 3;
9263 break;
9264
9265 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9266 salt_type = SALT_TYPE_EMBEDDED;
9267 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9268 opts_type = OPTS_TYPE_PT_GENERATE_BE
9269 | OPTS_TYPE_PT_ADD80
9270 | OPTS_TYPE_PT_UNICODE;
9271 kern_type = KERN_TYPE_OLDOFFICE34;
9272 dgst_size = DGST_SIZE_4_4;
9273 parse_func = oldoffice34_parse_hash;
9274 sort_by_digest = sort_by_digest_4_4;
9275 opti_type = OPTI_TYPE_ZERO_BYTE
9276 | OPTI_TYPE_PRECOMPUTE_INIT
9277 | OPTI_TYPE_NOT_ITERATED;
9278 dgst_pos0 = 0;
9279 dgst_pos1 = 1;
9280 dgst_pos2 = 2;
9281 dgst_pos3 = 3;
9282 break;
9283
9284 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9285 salt_type = SALT_TYPE_EMBEDDED;
9286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9287 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9288 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9289 dgst_size = DGST_SIZE_4_4;
9290 parse_func = oldoffice34cm1_parse_hash;
9291 sort_by_digest = sort_by_digest_4_4;
9292 opti_type = OPTI_TYPE_ZERO_BYTE
9293 | OPTI_TYPE_PRECOMPUTE_INIT
9294 | OPTI_TYPE_NOT_ITERATED;
9295 dgst_pos0 = 0;
9296 dgst_pos1 = 1;
9297 dgst_pos2 = 2;
9298 dgst_pos3 = 3;
9299 break;
9300
9301 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9302 salt_type = SALT_TYPE_EMBEDDED;
9303 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9304 opts_type = OPTS_TYPE_PT_GENERATE_BE
9305 | OPTS_TYPE_PT_ADD80
9306 | OPTS_TYPE_PT_UNICODE
9307 | OPTS_TYPE_PT_NEVERCRACK;
9308 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9309 dgst_size = DGST_SIZE_4_4;
9310 parse_func = oldoffice34cm2_parse_hash;
9311 sort_by_digest = sort_by_digest_4_4;
9312 opti_type = OPTI_TYPE_ZERO_BYTE
9313 | OPTI_TYPE_PRECOMPUTE_INIT
9314 | OPTI_TYPE_NOT_ITERATED;
9315 dgst_pos0 = 0;
9316 dgst_pos1 = 1;
9317 dgst_pos2 = 2;
9318 dgst_pos3 = 3;
9319 break;
9320
9321 case 9900: hash_type = HASH_TYPE_MD5;
9322 salt_type = SALT_TYPE_NONE;
9323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9324 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9325 kern_type = KERN_TYPE_RADMIN2;
9326 dgst_size = DGST_SIZE_4_4;
9327 parse_func = radmin2_parse_hash;
9328 sort_by_digest = sort_by_digest_4_4;
9329 opti_type = OPTI_TYPE_ZERO_BYTE
9330 | OPTI_TYPE_PRECOMPUTE_INIT
9331 | OPTI_TYPE_EARLY_SKIP
9332 | OPTI_TYPE_NOT_ITERATED
9333 | OPTI_TYPE_NOT_SALTED;
9334 dgst_pos0 = 0;
9335 dgst_pos1 = 3;
9336 dgst_pos2 = 2;
9337 dgst_pos3 = 1;
9338 break;
9339
9340 case 10000: hash_type = HASH_TYPE_SHA256;
9341 salt_type = SALT_TYPE_EMBEDDED;
9342 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9343 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9344 kern_type = KERN_TYPE_PBKDF2_SHA256;
9345 dgst_size = DGST_SIZE_4_32;
9346 parse_func = djangopbkdf2_parse_hash;
9347 sort_by_digest = sort_by_digest_4_32;
9348 opti_type = OPTI_TYPE_ZERO_BYTE;
9349 dgst_pos0 = 0;
9350 dgst_pos1 = 1;
9351 dgst_pos2 = 2;
9352 dgst_pos3 = 3;
9353 break;
9354
9355 case 10100: hash_type = HASH_TYPE_SIPHASH;
9356 salt_type = SALT_TYPE_EMBEDDED;
9357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9358 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9359 kern_type = KERN_TYPE_SIPHASH;
9360 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9361 parse_func = siphash_parse_hash;
9362 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9363 opti_type = OPTI_TYPE_ZERO_BYTE
9364 | OPTI_TYPE_NOT_ITERATED
9365 | OPTI_TYPE_RAW_HASH;
9366 dgst_pos0 = 0;
9367 dgst_pos1 = 1;
9368 dgst_pos2 = 2;
9369 dgst_pos3 = 3;
9370 break;
9371
9372 case 10200: hash_type = HASH_TYPE_MD5;
9373 salt_type = SALT_TYPE_EMBEDDED;
9374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9375 opts_type = OPTS_TYPE_PT_GENERATE_LE
9376 | OPTS_TYPE_ST_ADD80
9377 | OPTS_TYPE_ST_ADDBITS14;
9378 kern_type = KERN_TYPE_HMACMD5_PW;
9379 dgst_size = DGST_SIZE_4_4;
9380 parse_func = crammd5_parse_hash;
9381 sort_by_digest = sort_by_digest_4_4;
9382 opti_type = OPTI_TYPE_ZERO_BYTE
9383 | OPTI_TYPE_NOT_ITERATED;
9384 dgst_pos0 = 0;
9385 dgst_pos1 = 3;
9386 dgst_pos2 = 2;
9387 dgst_pos3 = 1;
9388 break;
9389
9390 case 10300: hash_type = HASH_TYPE_SHA1;
9391 salt_type = SALT_TYPE_EMBEDDED;
9392 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9393 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9394 kern_type = KERN_TYPE_SAPH_SHA1;
9395 dgst_size = DGST_SIZE_4_5;
9396 parse_func = saph_sha1_parse_hash;
9397 sort_by_digest = sort_by_digest_4_5;
9398 opti_type = OPTI_TYPE_ZERO_BYTE;
9399 dgst_pos0 = 0;
9400 dgst_pos1 = 1;
9401 dgst_pos2 = 2;
9402 dgst_pos3 = 3;
9403 break;
9404
9405 case 10400: hash_type = HASH_TYPE_PDFU16;
9406 salt_type = SALT_TYPE_EMBEDDED;
9407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9408 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9409 kern_type = KERN_TYPE_PDF11;
9410 dgst_size = DGST_SIZE_4_4;
9411 parse_func = pdf11_parse_hash;
9412 sort_by_digest = sort_by_digest_4_4;
9413 opti_type = OPTI_TYPE_ZERO_BYTE
9414 | OPTI_TYPE_NOT_ITERATED;
9415 dgst_pos0 = 0;
9416 dgst_pos1 = 1;
9417 dgst_pos2 = 2;
9418 dgst_pos3 = 3;
9419 break;
9420
9421 case 10410: hash_type = HASH_TYPE_PDFU16;
9422 salt_type = SALT_TYPE_EMBEDDED;
9423 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9424 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9425 kern_type = KERN_TYPE_PDF11CM1;
9426 dgst_size = DGST_SIZE_4_4;
9427 parse_func = pdf11cm1_parse_hash;
9428 sort_by_digest = sort_by_digest_4_4;
9429 opti_type = OPTI_TYPE_ZERO_BYTE
9430 | OPTI_TYPE_NOT_ITERATED;
9431 dgst_pos0 = 0;
9432 dgst_pos1 = 1;
9433 dgst_pos2 = 2;
9434 dgst_pos3 = 3;
9435 break;
9436
9437 case 10420: hash_type = HASH_TYPE_PDFU16;
9438 salt_type = SALT_TYPE_EMBEDDED;
9439 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9440 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9441 kern_type = KERN_TYPE_PDF11CM2;
9442 dgst_size = DGST_SIZE_4_4;
9443 parse_func = pdf11cm2_parse_hash;
9444 sort_by_digest = sort_by_digest_4_4;
9445 opti_type = OPTI_TYPE_ZERO_BYTE
9446 | OPTI_TYPE_NOT_ITERATED;
9447 dgst_pos0 = 0;
9448 dgst_pos1 = 1;
9449 dgst_pos2 = 2;
9450 dgst_pos3 = 3;
9451 break;
9452
9453 case 10500: hash_type = HASH_TYPE_PDFU16;
9454 salt_type = SALT_TYPE_EMBEDDED;
9455 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9456 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9457 kern_type = KERN_TYPE_PDF14;
9458 dgst_size = DGST_SIZE_4_4;
9459 parse_func = pdf14_parse_hash;
9460 sort_by_digest = sort_by_digest_4_4;
9461 opti_type = OPTI_TYPE_ZERO_BYTE
9462 | OPTI_TYPE_NOT_ITERATED;
9463 dgst_pos0 = 0;
9464 dgst_pos1 = 1;
9465 dgst_pos2 = 2;
9466 dgst_pos3 = 3;
9467 break;
9468
9469 case 10600: hash_type = HASH_TYPE_SHA256;
9470 salt_type = SALT_TYPE_EMBEDDED;
9471 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9472 opts_type = OPTS_TYPE_PT_GENERATE_BE
9473 | OPTS_TYPE_ST_ADD80
9474 | OPTS_TYPE_ST_ADDBITS15
9475 | OPTS_TYPE_HASH_COPY;
9476 kern_type = KERN_TYPE_SHA256_PWSLT;
9477 dgst_size = DGST_SIZE_4_8;
9478 parse_func = pdf17l3_parse_hash;
9479 sort_by_digest = sort_by_digest_4_8;
9480 opti_type = OPTI_TYPE_ZERO_BYTE
9481 | OPTI_TYPE_PRECOMPUTE_INIT
9482 | OPTI_TYPE_PRECOMPUTE_MERKLE
9483 | OPTI_TYPE_EARLY_SKIP
9484 | OPTI_TYPE_NOT_ITERATED
9485 | OPTI_TYPE_APPENDED_SALT
9486 | OPTI_TYPE_RAW_HASH;
9487 dgst_pos0 = 3;
9488 dgst_pos1 = 7;
9489 dgst_pos2 = 2;
9490 dgst_pos3 = 6;
9491 break;
9492
9493 case 10700: hash_type = HASH_TYPE_PDFU32;
9494 salt_type = SALT_TYPE_EMBEDDED;
9495 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9496 opts_type = OPTS_TYPE_PT_GENERATE_LE
9497 | OPTS_TYPE_HASH_COPY;
9498 kern_type = KERN_TYPE_PDF17L8;
9499 dgst_size = DGST_SIZE_4_8;
9500 parse_func = pdf17l8_parse_hash;
9501 sort_by_digest = sort_by_digest_4_8;
9502 opti_type = OPTI_TYPE_ZERO_BYTE
9503 | OPTI_TYPE_NOT_ITERATED;
9504 dgst_pos0 = 0;
9505 dgst_pos1 = 1;
9506 dgst_pos2 = 2;
9507 dgst_pos3 = 3;
9508 break;
9509
9510 case 10800: hash_type = HASH_TYPE_SHA384;
9511 salt_type = SALT_TYPE_NONE;
9512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9513 opts_type = OPTS_TYPE_PT_GENERATE_BE
9514 | OPTS_TYPE_PT_ADD80
9515 | OPTS_TYPE_PT_ADDBITS15;
9516 kern_type = KERN_TYPE_SHA384;
9517 dgst_size = DGST_SIZE_8_8;
9518 parse_func = sha384_parse_hash;
9519 sort_by_digest = sort_by_digest_8_8;
9520 opti_type = OPTI_TYPE_ZERO_BYTE
9521 | OPTI_TYPE_PRECOMPUTE_INIT
9522 | OPTI_TYPE_PRECOMPUTE_MERKLE
9523 | OPTI_TYPE_EARLY_SKIP
9524 | OPTI_TYPE_NOT_ITERATED
9525 | OPTI_TYPE_NOT_SALTED
9526 | OPTI_TYPE_RAW_HASH;
9527 dgst_pos0 = 6;
9528 dgst_pos1 = 7;
9529 dgst_pos2 = 4;
9530 dgst_pos3 = 5;
9531 break;
9532
9533 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9534 salt_type = SALT_TYPE_EMBEDDED;
9535 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9536 opts_type = OPTS_TYPE_PT_GENERATE_LE
9537 | OPTS_TYPE_ST_BASE64
9538 | OPTS_TYPE_HASH_COPY;
9539 kern_type = KERN_TYPE_PBKDF2_SHA256;
9540 dgst_size = DGST_SIZE_4_32;
9541 parse_func = pbkdf2_sha256_parse_hash;
9542 sort_by_digest = sort_by_digest_4_32;
9543 opti_type = OPTI_TYPE_ZERO_BYTE;
9544 dgst_pos0 = 0;
9545 dgst_pos1 = 1;
9546 dgst_pos2 = 2;
9547 dgst_pos3 = 3;
9548 break;
9549
9550 case 11000: hash_type = HASH_TYPE_MD5;
9551 salt_type = SALT_TYPE_INTERN;
9552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9553 opts_type = OPTS_TYPE_PT_GENERATE_LE
9554 | OPTS_TYPE_PT_ADD80;
9555 kern_type = KERN_TYPE_PRESTASHOP;
9556 dgst_size = DGST_SIZE_4_4;
9557 parse_func = prestashop_parse_hash;
9558 sort_by_digest = sort_by_digest_4_4;
9559 opti_type = OPTI_TYPE_ZERO_BYTE
9560 | OPTI_TYPE_PRECOMPUTE_INIT
9561 | OPTI_TYPE_NOT_ITERATED
9562 | OPTI_TYPE_PREPENDED_SALT;
9563 dgst_pos0 = 0;
9564 dgst_pos1 = 3;
9565 dgst_pos2 = 2;
9566 dgst_pos3 = 1;
9567 break;
9568
9569 case 11100: hash_type = HASH_TYPE_MD5;
9570 salt_type = SALT_TYPE_EMBEDDED;
9571 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9572 opts_type = OPTS_TYPE_PT_GENERATE_LE
9573 | OPTS_TYPE_ST_ADD80;
9574 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9575 dgst_size = DGST_SIZE_4_4;
9576 parse_func = postgresql_auth_parse_hash;
9577 sort_by_digest = sort_by_digest_4_4;
9578 opti_type = OPTI_TYPE_ZERO_BYTE
9579 | OPTI_TYPE_PRECOMPUTE_INIT
9580 | OPTI_TYPE_PRECOMPUTE_MERKLE
9581 | OPTI_TYPE_EARLY_SKIP;
9582 dgst_pos0 = 0;
9583 dgst_pos1 = 3;
9584 dgst_pos2 = 2;
9585 dgst_pos3 = 1;
9586 break;
9587
9588 case 11200: hash_type = HASH_TYPE_SHA1;
9589 salt_type = SALT_TYPE_EMBEDDED;
9590 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9591 opts_type = OPTS_TYPE_PT_GENERATE_BE
9592 | OPTS_TYPE_PT_ADD80
9593 | OPTS_TYPE_ST_HEX;
9594 kern_type = KERN_TYPE_MYSQL_AUTH;
9595 dgst_size = DGST_SIZE_4_5;
9596 parse_func = mysql_auth_parse_hash;
9597 sort_by_digest = sort_by_digest_4_5;
9598 opti_type = OPTI_TYPE_ZERO_BYTE
9599 | OPTI_TYPE_EARLY_SKIP;
9600 dgst_pos0 = 3;
9601 dgst_pos1 = 4;
9602 dgst_pos2 = 2;
9603 dgst_pos3 = 1;
9604 break;
9605
9606 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9607 salt_type = SALT_TYPE_EMBEDDED;
9608 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9609 opts_type = OPTS_TYPE_PT_GENERATE_LE
9610 | OPTS_TYPE_ST_HEX
9611 | OPTS_TYPE_ST_ADD80;
9612 kern_type = KERN_TYPE_BITCOIN_WALLET;
9613 dgst_size = DGST_SIZE_4_4;
9614 parse_func = bitcoin_wallet_parse_hash;
9615 sort_by_digest = sort_by_digest_4_4;
9616 opti_type = OPTI_TYPE_ZERO_BYTE;
9617 dgst_pos0 = 0;
9618 dgst_pos1 = 1;
9619 dgst_pos2 = 2;
9620 dgst_pos3 = 3;
9621 break;
9622
9623 case 11400: hash_type = HASH_TYPE_MD5;
9624 salt_type = SALT_TYPE_EMBEDDED;
9625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9626 opts_type = OPTS_TYPE_PT_GENERATE_LE
9627 | OPTS_TYPE_PT_ADD80
9628 | OPTS_TYPE_HASH_COPY;
9629 kern_type = KERN_TYPE_SIP_AUTH;
9630 dgst_size = DGST_SIZE_4_4;
9631 parse_func = sip_auth_parse_hash;
9632 sort_by_digest = sort_by_digest_4_4;
9633 opti_type = OPTI_TYPE_ZERO_BYTE;
9634 dgst_pos0 = 0;
9635 dgst_pos1 = 3;
9636 dgst_pos2 = 2;
9637 dgst_pos3 = 1;
9638 break;
9639
9640 case 11500: hash_type = HASH_TYPE_CRC32;
9641 salt_type = SALT_TYPE_INTERN;
9642 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9643 opts_type = OPTS_TYPE_PT_GENERATE_LE
9644 | OPTS_TYPE_ST_GENERATE_LE
9645 | OPTS_TYPE_ST_HEX;
9646 kern_type = KERN_TYPE_CRC32;
9647 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9648 parse_func = crc32_parse_hash;
9649 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9650 opti_type = OPTI_TYPE_ZERO_BYTE;
9651 dgst_pos0 = 0;
9652 dgst_pos1 = 1;
9653 dgst_pos2 = 2;
9654 dgst_pos3 = 3;
9655 break;
9656
9657 case 11600: hash_type = HASH_TYPE_AES;
9658 salt_type = SALT_TYPE_EMBEDDED;
9659 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9660 opts_type = OPTS_TYPE_PT_GENERATE_LE
9661 | OPTS_TYPE_PT_NEVERCRACK;
9662 kern_type = KERN_TYPE_SEVEN_ZIP;
9663 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9664 parse_func = seven_zip_parse_hash;
9665 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9666 opti_type = OPTI_TYPE_ZERO_BYTE;
9667 dgst_pos0 = 0;
9668 dgst_pos1 = 1;
9669 dgst_pos2 = 2;
9670 dgst_pos3 = 3;
9671 break;
9672
9673 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9674 salt_type = SALT_TYPE_NONE;
9675 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9676 opts_type = OPTS_TYPE_PT_GENERATE_LE
9677 | OPTS_TYPE_PT_ADD01;
9678 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9679 dgst_size = DGST_SIZE_4_8;
9680 parse_func = gost2012sbog_256_parse_hash;
9681 sort_by_digest = sort_by_digest_4_8;
9682 opti_type = OPTI_TYPE_ZERO_BYTE;
9683 dgst_pos0 = 0;
9684 dgst_pos1 = 1;
9685 dgst_pos2 = 2;
9686 dgst_pos3 = 3;
9687 break;
9688
9689 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9690 salt_type = SALT_TYPE_NONE;
9691 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9692 opts_type = OPTS_TYPE_PT_GENERATE_LE
9693 | OPTS_TYPE_PT_ADD01;
9694 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9695 dgst_size = DGST_SIZE_4_16;
9696 parse_func = gost2012sbog_512_parse_hash;
9697 sort_by_digest = sort_by_digest_4_16;
9698 opti_type = OPTI_TYPE_ZERO_BYTE;
9699 dgst_pos0 = 0;
9700 dgst_pos1 = 1;
9701 dgst_pos2 = 2;
9702 dgst_pos3 = 3;
9703 break;
9704
9705 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9706 salt_type = SALT_TYPE_EMBEDDED;
9707 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9708 opts_type = OPTS_TYPE_PT_GENERATE_LE
9709 | OPTS_TYPE_ST_BASE64
9710 | OPTS_TYPE_HASH_COPY;
9711 kern_type = KERN_TYPE_PBKDF2_MD5;
9712 dgst_size = DGST_SIZE_4_32;
9713 parse_func = pbkdf2_md5_parse_hash;
9714 sort_by_digest = sort_by_digest_4_32;
9715 opti_type = OPTI_TYPE_ZERO_BYTE;
9716 dgst_pos0 = 0;
9717 dgst_pos1 = 1;
9718 dgst_pos2 = 2;
9719 dgst_pos3 = 3;
9720 break;
9721
9722 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9723 salt_type = SALT_TYPE_EMBEDDED;
9724 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9725 opts_type = OPTS_TYPE_PT_GENERATE_LE
9726 | OPTS_TYPE_ST_BASE64
9727 | OPTS_TYPE_HASH_COPY;
9728 kern_type = KERN_TYPE_PBKDF2_SHA1;
9729 dgst_size = DGST_SIZE_4_32;
9730 parse_func = pbkdf2_sha1_parse_hash;
9731 sort_by_digest = sort_by_digest_4_32;
9732 opti_type = OPTI_TYPE_ZERO_BYTE;
9733 dgst_pos0 = 0;
9734 dgst_pos1 = 1;
9735 dgst_pos2 = 2;
9736 dgst_pos3 = 3;
9737 break;
9738
9739 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9740 salt_type = SALT_TYPE_EMBEDDED;
9741 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9742 opts_type = OPTS_TYPE_PT_GENERATE_LE
9743 | OPTS_TYPE_ST_BASE64
9744 | OPTS_TYPE_HASH_COPY;
9745 kern_type = KERN_TYPE_PBKDF2_SHA512;
9746 dgst_size = DGST_SIZE_8_16;
9747 parse_func = pbkdf2_sha512_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 12200: hash_type = HASH_TYPE_ECRYPTFS;
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_ECRYPTFS;
9761 dgst_size = DGST_SIZE_8_8;
9762 parse_func = ecryptfs_parse_hash;
9763 sort_by_digest = sort_by_digest_8_8;
9764 opti_type = OPTI_TYPE_ZERO_BYTE;
9765 dgst_pos0 = 0;
9766 dgst_pos1 = 1;
9767 dgst_pos2 = 2;
9768 dgst_pos3 = 3;
9769 break;
9770
9771 case 12300: hash_type = HASH_TYPE_ORACLET;
9772 salt_type = SALT_TYPE_EMBEDDED;
9773 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9774 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9775 kern_type = KERN_TYPE_ORACLET;
9776 dgst_size = DGST_SIZE_8_16;
9777 parse_func = oraclet_parse_hash;
9778 sort_by_digest = sort_by_digest_8_16;
9779 opti_type = OPTI_TYPE_ZERO_BYTE;
9780 dgst_pos0 = 0;
9781 dgst_pos1 = 1;
9782 dgst_pos2 = 2;
9783 dgst_pos3 = 3;
9784 break;
9785
9786 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9787 salt_type = SALT_TYPE_EMBEDDED;
9788 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9789 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9790 kern_type = KERN_TYPE_BSDICRYPT;
9791 dgst_size = DGST_SIZE_4_4;
9792 parse_func = bsdicrypt_parse_hash;
9793 sort_by_digest = sort_by_digest_4_4;
9794 opti_type = OPTI_TYPE_ZERO_BYTE
9795 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9796 dgst_pos0 = 0;
9797 dgst_pos1 = 1;
9798 dgst_pos2 = 2;
9799 dgst_pos3 = 3;
9800 break;
9801
9802 case 12500: hash_type = HASH_TYPE_RAR3HP;
9803 salt_type = SALT_TYPE_EMBEDDED;
9804 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9805 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9806 kern_type = KERN_TYPE_RAR3;
9807 dgst_size = DGST_SIZE_4_4;
9808 parse_func = rar3hp_parse_hash;
9809 sort_by_digest = sort_by_digest_4_4;
9810 opti_type = OPTI_TYPE_ZERO_BYTE;
9811 dgst_pos0 = 0;
9812 dgst_pos1 = 1;
9813 dgst_pos2 = 2;
9814 dgst_pos3 = 3;
9815 break;
9816
9817 case 12600: hash_type = HASH_TYPE_SHA256;
9818 salt_type = SALT_TYPE_INTERN;
9819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9820 opts_type = OPTS_TYPE_PT_GENERATE_BE
9821 | OPTS_TYPE_PT_ADD80;
9822 kern_type = KERN_TYPE_CF10;
9823 dgst_size = DGST_SIZE_4_8;
9824 parse_func = cf10_parse_hash;
9825 sort_by_digest = sort_by_digest_4_8;
9826 opti_type = OPTI_TYPE_ZERO_BYTE
9827 | OPTI_TYPE_PRECOMPUTE_INIT
9828 | OPTI_TYPE_EARLY_SKIP
9829 | OPTI_TYPE_NOT_ITERATED;
9830 dgst_pos0 = 3;
9831 dgst_pos1 = 7;
9832 dgst_pos2 = 2;
9833 dgst_pos3 = 6;
9834 break;
9835
9836 case 12700: hash_type = HASH_TYPE_AES;
9837 salt_type = SALT_TYPE_EMBEDDED;
9838 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9839 opts_type = OPTS_TYPE_PT_GENERATE_LE
9840 | OPTS_TYPE_HASH_COPY;
9841 kern_type = KERN_TYPE_MYWALLET;
9842 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9843 parse_func = mywallet_parse_hash;
9844 sort_by_digest = sort_by_digest_4_5;
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 12800: 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_MS_DRSR;
9857 dgst_size = DGST_SIZE_4_8;
9858 parse_func = ms_drsr_parse_hash;
9859 sort_by_digest = sort_by_digest_4_8;
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 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9868 salt_type = SALT_TYPE_EMBEDDED;
9869 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9870 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9871 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
9872 dgst_size = DGST_SIZE_4_8;
9873 parse_func = androidfde_samsung_parse_hash;
9874 sort_by_digest = sort_by_digest_4_8;
9875 opti_type = OPTI_TYPE_ZERO_BYTE;
9876 dgst_pos0 = 0;
9877 dgst_pos1 = 1;
9878 dgst_pos2 = 2;
9879 dgst_pos3 = 3;
9880 break;
9881
9882 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
9883 salt_type = SALT_TYPE_EMBEDDED;
9884 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9885 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9886 kern_type = KERN_TYPE_RAR5;
9887 dgst_size = DGST_SIZE_4_4;
9888 parse_func = rar5_parse_hash;
9889 sort_by_digest = sort_by_digest_4_4;
9890 opti_type = OPTI_TYPE_ZERO_BYTE;
9891 dgst_pos0 = 0;
9892 dgst_pos1 = 1;
9893 dgst_pos2 = 2;
9894 dgst_pos3 = 3;
9895 break;
9896
9897 default: usage_mini_print (PROGNAME); return (-1);
9898 }
9899
9900 /**
9901 * transpose
9902 */
9903
9904 data.parse_func = parse_func;
9905
9906 /**
9907 * misc stuff
9908 */
9909
9910 if (hex_salt)
9911 {
9912 if (salt_type == SALT_TYPE_INTERN)
9913 {
9914 opts_type |= OPTS_TYPE_ST_HEX;
9915 }
9916 else
9917 {
9918 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9919
9920 return (-1);
9921 }
9922 }
9923
9924 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9925 | (salt_type == SALT_TYPE_EXTERN)
9926 | (salt_type == SALT_TYPE_EMBEDDED)
9927 | (salt_type == SALT_TYPE_VIRTUAL));
9928
9929 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9930
9931 data.hash_type = hash_type;
9932 data.attack_mode = attack_mode;
9933 data.attack_kern = attack_kern;
9934 data.attack_exec = attack_exec;
9935 data.kern_type = kern_type;
9936 data.opts_type = opts_type;
9937 data.dgst_size = dgst_size;
9938 data.salt_type = salt_type;
9939 data.isSalted = isSalted;
9940 data.sort_by_digest = sort_by_digest;
9941 data.dgst_pos0 = dgst_pos0;
9942 data.dgst_pos1 = dgst_pos1;
9943 data.dgst_pos2 = dgst_pos2;
9944 data.dgst_pos3 = dgst_pos3;
9945
9946 esalt_size = 0;
9947
9948 switch (hash_mode)
9949 {
9950 case 2500: esalt_size = sizeof (wpa_t); break;
9951 case 5300: esalt_size = sizeof (ikepsk_t); break;
9952 case 5400: esalt_size = sizeof (ikepsk_t); break;
9953 case 5500: esalt_size = sizeof (netntlm_t); break;
9954 case 5600: esalt_size = sizeof (netntlm_t); break;
9955 case 6211:
9956 case 6212:
9957 case 6213:
9958 case 6221:
9959 case 6222:
9960 case 6223:
9961 case 6231:
9962 case 6232:
9963 case 6233:
9964 case 6241:
9965 case 6242:
9966 case 6243: esalt_size = sizeof (tc_t); break;
9967 case 6600: esalt_size = sizeof (agilekey_t); break;
9968 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9969 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9970 case 7300: esalt_size = sizeof (rakp_t); break;
9971 case 7500: esalt_size = sizeof (krb5pa_t); break;
9972 case 8200: esalt_size = sizeof (cloudkey_t); break;
9973 case 8800: esalt_size = sizeof (androidfde_t); break;
9974 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9975 case 9400: esalt_size = sizeof (office2007_t); break;
9976 case 9500: esalt_size = sizeof (office2010_t); break;
9977 case 9600: esalt_size = sizeof (office2013_t); break;
9978 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9979 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9980 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9981 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9982 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9983 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9984 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9985 case 10200: esalt_size = sizeof (cram_md5_t); break;
9986 case 10400: esalt_size = sizeof (pdf_t); break;
9987 case 10410: esalt_size = sizeof (pdf_t); break;
9988 case 10420: esalt_size = sizeof (pdf_t); break;
9989 case 10500: esalt_size = sizeof (pdf_t); break;
9990 case 10600: esalt_size = sizeof (pdf_t); break;
9991 case 10700: esalt_size = sizeof (pdf_t); break;
9992 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9993 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9994 case 11400: esalt_size = sizeof (sip_t); break;
9995 case 11600: esalt_size = sizeof (seven_zip_t); break;
9996 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9997 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9998 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9999 case 13000: esalt_size = sizeof (rar5_t); break;
10000 }
10001
10002 data.esalt_size = esalt_size;
10003
10004 /**
10005 * choose dictionary parser
10006 */
10007
10008 if (hash_type == HASH_TYPE_LM)
10009 {
10010 get_next_word_func = get_next_word_lm;
10011 }
10012 else if (opts_type & OPTS_TYPE_PT_UPPER)
10013 {
10014 get_next_word_func = get_next_word_uc;
10015 }
10016 else
10017 {
10018 get_next_word_func = get_next_word_std;
10019 }
10020
10021 /**
10022 * dictstat
10023 */
10024
10025 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10026
10027 #ifdef _POSIX
10028 size_t dictstat_nmemb = 0;
10029 #endif
10030
10031 #ifdef _WIN
10032 uint dictstat_nmemb = 0;
10033 #endif
10034
10035 char dictstat[256];
10036
10037 FILE *dictstat_fp = NULL;
10038
10039 if (keyspace == 0)
10040 {
10041 memset (dictstat, 0, sizeof (dictstat));
10042
10043 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10044
10045 dictstat_fp = fopen (dictstat, "rb");
10046
10047 if (dictstat_fp)
10048 {
10049 #ifdef _POSIX
10050 struct stat tmpstat;
10051
10052 fstat (fileno (dictstat_fp), &tmpstat);
10053 #endif
10054
10055 #ifdef _WIN
10056 struct stat64 tmpstat;
10057
10058 _fstat64 (fileno (dictstat_fp), &tmpstat);
10059 #endif
10060
10061 if (tmpstat.st_mtime < COMPTIME)
10062 {
10063 /* with v0.15 the format changed so we have to ensure user is using a good version
10064 since there is no version-header in the dictstat file */
10065
10066 fclose (dictstat_fp);
10067
10068 unlink (dictstat);
10069 }
10070 else
10071 {
10072 while (!feof (dictstat_fp))
10073 {
10074 dictstat_t d;
10075
10076 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10077
10078 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10079
10080 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10081 {
10082 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10083
10084 return -1;
10085 }
10086 }
10087
10088 fclose (dictstat_fp);
10089 }
10090 }
10091 }
10092
10093 /**
10094 * potfile
10095 */
10096
10097 char potfile[256] = { 0 };
10098
10099 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10100
10101 data.pot_fp = NULL;
10102
10103 FILE *out_fp = NULL;
10104 FILE *pot_fp = NULL;
10105
10106 if (show == 1 || left == 1)
10107 {
10108 pot_fp = fopen (potfile, "rb");
10109
10110 if (pot_fp == NULL)
10111 {
10112 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10113
10114 return (-1);
10115 }
10116
10117 if (outfile != NULL)
10118 {
10119 if ((out_fp = fopen (outfile, "ab")) == NULL)
10120 {
10121 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10122
10123 fclose (pot_fp);
10124
10125 return (-1);
10126 }
10127 }
10128 else
10129 {
10130 out_fp = stdout;
10131 }
10132 }
10133 else
10134 {
10135 if (potfile_disable == 0)
10136 {
10137 pot_fp = fopen (potfile, "ab");
10138
10139 if (pot_fp == NULL)
10140 {
10141 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10142
10143 return (-1);
10144 }
10145
10146 data.pot_fp = pot_fp;
10147 }
10148 }
10149
10150 pot_t *pot = NULL;
10151
10152 uint pot_cnt = 0;
10153 uint pot_avail = 0;
10154
10155 if (show == 1 || left == 1)
10156 {
10157 SUPPRESS_OUTPUT = 1;
10158
10159 pot_avail = count_lines (pot_fp);
10160
10161 rewind (pot_fp);
10162
10163 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10164
10165 uint pot_hashes_avail = 0;
10166
10167 uint line_num = 0;
10168
10169 while (!feof (pot_fp))
10170 {
10171 line_num++;
10172
10173 char line_buf[BUFSIZ];
10174
10175 int line_len = fgetl (pot_fp, line_buf);
10176
10177 if (line_len == 0) continue;
10178
10179 char *plain_buf = line_buf + line_len;
10180
10181 pot_t *pot_ptr = &pot[pot_cnt];
10182
10183 hash_t *hashes_buf = &pot_ptr->hash;
10184
10185 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10186 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10187
10188 if (pot_cnt == pot_hashes_avail)
10189 {
10190 uint pos = 0;
10191
10192 for (pos = 0; pos < INCR_POT; pos++)
10193 {
10194 if ((pot_cnt + pos) >= pot_avail) break;
10195
10196 pot_t *tmp_pot = &pot[pot_cnt + pos];
10197
10198 hash_t *tmp_hash = &tmp_pot->hash;
10199
10200 tmp_hash->digest = mymalloc (dgst_size);
10201
10202 if (isSalted)
10203 {
10204 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10205 }
10206
10207 if (esalt_size)
10208 {
10209 tmp_hash->esalt = mymalloc (esalt_size);
10210 }
10211
10212 pot_hashes_avail++;
10213 }
10214 }
10215
10216 int plain_len = 0;
10217
10218 int parser_status;
10219
10220 int iter = MAX_CUT_TRIES;
10221
10222 do
10223 {
10224 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10225 {
10226 if (line_buf[i] == ':')
10227 {
10228 line_len--;
10229
10230 break;
10231 }
10232 }
10233
10234 if (data.hash_mode != 2500)
10235 {
10236 parser_status = parse_func (line_buf, line_len, hashes_buf);
10237 }
10238 else
10239 {
10240 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10241
10242 if (line_len > max_salt_size)
10243 {
10244 parser_status = PARSER_GLOBAL_LENGTH;
10245 }
10246 else
10247 {
10248 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10249
10250 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10251
10252 hashes_buf->salt->salt_len = line_len;
10253
10254 parser_status = PARSER_OK;
10255 }
10256 }
10257
10258 // if NOT parsed without error, we add the ":" to the plain
10259
10260 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10261 {
10262 plain_len++;
10263 plain_buf--;
10264 }
10265
10266 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10267
10268 if (parser_status < PARSER_GLOBAL_ZERO)
10269 {
10270 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10271
10272 continue;
10273 }
10274
10275 if (plain_len >= 255) continue;
10276
10277 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10278
10279 pot_ptr->plain_len = plain_len;
10280
10281 pot_cnt++;
10282 }
10283
10284 fclose (pot_fp);
10285
10286 SUPPRESS_OUTPUT = 0;
10287
10288 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10289 }
10290
10291 /**
10292 * kernel accel and loops auto adjustment
10293 */
10294
10295 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10296 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10297
10298 if (workload_profile == 1)
10299 {
10300 kernel_loops /= 8;
10301 kernel_accel /= 4;
10302
10303 if (kernel_loops == 0) kernel_loops = 8;
10304 if (kernel_accel == 0) kernel_accel = 2;
10305 }
10306 else if (workload_profile == 3)
10307 {
10308 kernel_loops *= 8;
10309 kernel_accel *= 4;
10310
10311 if (kernel_loops > 1024) kernel_loops = 1024;
10312 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10313 }
10314
10315 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10316
10317 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10318 {
10319 kernel_loops = 1024;
10320 }
10321
10322 if (hash_mode == 12500)
10323 {
10324 kernel_loops = ROUNDS_RAR3 / 16;
10325 }
10326
10327 data.kernel_accel = kernel_accel;
10328 data.kernel_loops = kernel_loops;
10329
10330 /**
10331 * word len
10332 */
10333
10334 uint pw_min = PW_MIN;
10335 uint pw_max = PW_MAX;
10336
10337 switch (hash_mode)
10338 {
10339 case 400: if (pw_max > 40) pw_max = 40;
10340 break;
10341 case 500: if (pw_max > 16) pw_max = 16;
10342 break;
10343 case 1500: if (pw_max > 8) pw_max = 8;
10344 break;
10345 case 1600: if (pw_max > 16) pw_max = 16;
10346 break;
10347 case 1800: if (pw_max > 16) pw_max = 16;
10348 break;
10349 case 2100: if (pw_max > 16) pw_max = 16;
10350 break;
10351 case 2500: if (pw_min < 8) pw_min = 8;
10352 break;
10353 case 3000: if (pw_max > 7) pw_max = 7;
10354 break;
10355 case 5200: if (pw_max > 24) pw_max = 24;
10356 break;
10357 case 5800: if (pw_max > 16) pw_max = 16;
10358 break;
10359 case 6300: if (pw_max > 16) pw_max = 16;
10360 break;
10361 case 7400: if (pw_max > 16) pw_max = 16;
10362 break;
10363 case 7900: if (pw_max > 48) pw_max = 48;
10364 break;
10365 case 8500: if (pw_max > 8) pw_max = 8;
10366 break;
10367 case 8600: if (pw_max > 16) pw_max = 16;
10368 break;
10369 case 9710: pw_min = 5;
10370 pw_max = 5;
10371 break;
10372 case 9810: pw_min = 5;
10373 pw_max = 5;
10374 break;
10375 case 10410: pw_min = 5;
10376 pw_max = 5;
10377 break;
10378 case 10300: if (pw_max < 3) pw_min = 3;
10379 if (pw_max > 40) pw_max = 40;
10380 break;
10381 case 10500: if (pw_max < 3) pw_min = 3;
10382 if (pw_max > 40) pw_max = 40;
10383 break;
10384 case 10700: if (pw_max > 16) pw_max = 16;
10385 break;
10386 case 11300: if (pw_max > 40) pw_max = 40;
10387 break;
10388 case 12500: if (pw_max > 20) pw_max = 20;
10389 break;
10390 case 12800: if (pw_max > 24) pw_max = 24;
10391 break;
10392 }
10393
10394 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10395 {
10396 switch (attack_kern)
10397 {
10398 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10399 break;
10400 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10401 break;
10402 }
10403 }
10404
10405 /**
10406 * charsets : keep them together for more easy maintainnce
10407 */
10408
10409 cs_t mp_sys[6] = { { { 0 }, 0 } };
10410 cs_t mp_usr[4] = { { { 0 }, 0 } };
10411
10412 mp_setup_sys (mp_sys);
10413
10414 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10415 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10416 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10417 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10418
10419 /**
10420 * load hashes, part I: find input mode, count hashes
10421 */
10422
10423 uint hashlist_mode = 0;
10424 uint hashlist_format = HLFMT_HASHCAT;
10425
10426 uint hashes_avail = 0;
10427
10428 if (benchmark == 0)
10429 {
10430 struct stat f;
10431
10432 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10433
10434 if ((hash_mode == 2500) ||
10435 (hash_mode == 5200) ||
10436 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10437 (hash_mode == 9000))
10438 {
10439 hashlist_mode = HL_MODE_ARG;
10440
10441 char *hashfile = myargv[optind];
10442
10443 data.hashfile = hashfile;
10444
10445 logfile_top_var_string ("target", hashfile);
10446 }
10447
10448 if (hashlist_mode == HL_MODE_ARG)
10449 {
10450 if (hash_mode == 2500)
10451 {
10452 struct stat st;
10453
10454 if (stat (data.hashfile, &st) == -1)
10455 {
10456 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10457
10458 return (-1);
10459 }
10460
10461 hashes_avail = st.st_size / sizeof (hccap_t);
10462 }
10463 else
10464 {
10465 hashes_avail = 1;
10466 }
10467 }
10468 else if (hashlist_mode == HL_MODE_FILE)
10469 {
10470 char *hashfile = myargv[optind];
10471
10472 data.hashfile = hashfile;
10473
10474 logfile_top_var_string ("target", hashfile);
10475
10476 FILE *fp = NULL;
10477
10478 if ((fp = fopen (hashfile, "rb")) == NULL)
10479 {
10480 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10481
10482 return (-1);
10483 }
10484
10485 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10486
10487 hashes_avail = count_lines (fp);
10488
10489 rewind (fp);
10490
10491 if (hashes_avail == 0)
10492 {
10493 log_error ("ERROR: hashfile is empty or corrupt");
10494
10495 fclose (fp);
10496
10497 return (-1);
10498 }
10499
10500 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10501
10502 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10503 {
10504 log_error ("ERROR: remove not supported in native hashfile-format mode");
10505
10506 fclose (fp);
10507
10508 return (-1);
10509 }
10510
10511 fclose (fp);
10512 }
10513 }
10514 else
10515 {
10516 hashlist_mode = HL_MODE_ARG;
10517
10518 hashes_avail = 1;
10519 }
10520
10521 if (hash_mode == 3000) hashes_avail *= 2;
10522
10523 data.hashlist_mode = hashlist_mode;
10524 data.hashlist_format = hashlist_format;
10525
10526 logfile_top_uint (hashlist_mode);
10527 logfile_top_uint (hashlist_format);
10528
10529 /**
10530 * load hashes, part II: allocate required memory, set pointers
10531 */
10532
10533 hash_t *hashes_buf = NULL;
10534 void *digests_buf = NULL;
10535 salt_t *salts_buf = NULL;
10536 void *esalts_buf = NULL;
10537
10538 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10539
10540 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10541
10542 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10543 {
10544 u32 hash_pos;
10545
10546 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10547 {
10548 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10549
10550 hashes_buf[hash_pos].hash_info = hash_info;
10551
10552 if (username && (remove || show || left))
10553 {
10554 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10555 }
10556
10557 if (benchmark)
10558 {
10559 hash_info->orighash = (char *) mymalloc (256);
10560 }
10561 }
10562 }
10563
10564 if (isSalted)
10565 {
10566 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10567
10568 if (esalt_size)
10569 {
10570 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10571 }
10572 }
10573 else
10574 {
10575 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10576 }
10577
10578 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10579 {
10580 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10581
10582 if (isSalted)
10583 {
10584 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10585
10586 if (esalt_size)
10587 {
10588 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10589 }
10590 }
10591 else
10592 {
10593 hashes_buf[hash_pos].salt = &salts_buf[0];
10594 }
10595 }
10596
10597 /**
10598 * load hashes, part III: parse hashes or generate them if benchmark
10599 */
10600
10601 uint hashes_cnt = 0;
10602
10603 if (benchmark == 0)
10604 {
10605 if (keyspace == 1)
10606 {
10607 // useless to read hash file for keyspace, cheat a little bit w/ optind
10608 }
10609 else if (hashes_avail == 0)
10610 {
10611 }
10612 else if (hashlist_mode == HL_MODE_ARG)
10613 {
10614 char *input_buf = myargv[optind];
10615
10616 uint input_len = strlen (input_buf);
10617
10618 logfile_top_var_string ("target", input_buf);
10619
10620 char *hash_buf = NULL;
10621 int hash_len = 0;
10622
10623 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10624
10625 if (hash_len)
10626 {
10627 if (opts_type & OPTS_TYPE_HASH_COPY)
10628 {
10629 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10630
10631 hash_info_tmp->orighash = mystrdup (hash_buf);
10632 }
10633
10634 if (isSalted)
10635 {
10636 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10637 }
10638
10639 int parser_status = PARSER_OK;
10640
10641 if (hash_mode == 2500)
10642 {
10643 if (hash_len == 0)
10644 {
10645 log_error ("ERROR: hccap file not specified");
10646
10647 return (-1);
10648 }
10649
10650 hashlist_mode = HL_MODE_FILE;
10651
10652 data.hashlist_mode = hashlist_mode;
10653
10654 FILE *fp = fopen (hash_buf, "rb");
10655
10656 if (fp == NULL)
10657 {
10658 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10659
10660 return (-1);
10661 }
10662
10663 if (hashes_avail < 1)
10664 {
10665 log_error ("ERROR: hccap file is empty or corrupt");
10666
10667 fclose (fp);
10668
10669 return (-1);
10670 }
10671
10672 uint hccap_size = sizeof (hccap_t);
10673
10674 char in[hccap_size];
10675
10676 while (!feof (fp))
10677 {
10678 int n = fread (&in, hccap_size, 1, fp);
10679
10680 if (n != 1)
10681 {
10682 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10683
10684 break;
10685 }
10686
10687 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10688
10689 if (parser_status != PARSER_OK)
10690 {
10691 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10692
10693 continue;
10694 }
10695
10696 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10697
10698 if ((show == 1) || (left == 1))
10699 {
10700 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10701
10702 char *salt_ptr = (char *) tmp_salt->salt_buf;
10703
10704 int cur_pos = tmp_salt->salt_len;
10705 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10706
10707 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10708
10709 u8 *pke_ptr = (u8 *) wpa->pke;
10710
10711 // do the appending task
10712
10713 snprintf (salt_ptr + cur_pos,
10714 rem_len,
10715 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10716 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10717 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10718
10719
10720 // memset () the remaining part of the salt
10721
10722 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10723 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10724
10725 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10726
10727 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10728 }
10729
10730 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);
10731 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);
10732
10733 hashes_cnt++;
10734 }
10735
10736 fclose (fp);
10737 }
10738 else if (hash_mode == 3000)
10739 {
10740 if (hash_len == 32)
10741 {
10742 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10743
10744 hash_t *lm_hash_left = NULL;
10745
10746 if (parser_status == PARSER_OK)
10747 {
10748 lm_hash_left = &hashes_buf[hashes_cnt];
10749
10750 hashes_cnt++;
10751 }
10752 else
10753 {
10754 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10755 }
10756
10757
10758 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10759
10760 hash_t *lm_hash_right = NULL;
10761
10762 if (parser_status == PARSER_OK)
10763 {
10764 lm_hash_right = &hashes_buf[hashes_cnt];
10765
10766 hashes_cnt++;
10767 }
10768 else
10769 {
10770 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10771 }
10772
10773 // show / left
10774
10775 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10776 {
10777 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);
10778 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);
10779 }
10780 }
10781 else
10782 {
10783 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10784
10785 if (parser_status == PARSER_OK)
10786 {
10787 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10788 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10789 }
10790
10791 if (parser_status == PARSER_OK)
10792 {
10793 hashes_cnt++;
10794 }
10795 else
10796 {
10797 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10798 }
10799 }
10800 }
10801 else
10802 {
10803 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10804
10805 if (parser_status == PARSER_OK)
10806 {
10807 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10808 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10809 }
10810
10811 if (parser_status == PARSER_OK)
10812 {
10813 hashes_cnt++;
10814 }
10815 else
10816 {
10817 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10818 }
10819 }
10820 }
10821 }
10822 else if (hashlist_mode == HL_MODE_FILE)
10823 {
10824 char *hashfile = data.hashfile;
10825
10826 FILE *fp;
10827
10828 if ((fp = fopen (hashfile, "rb")) == NULL)
10829 {
10830 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10831
10832 return (-1);
10833 }
10834
10835 uint line_num = 0;
10836
10837 while (!feof (fp))
10838 {
10839 line_num++;
10840
10841 char line_buf[BUFSIZ];
10842
10843 int line_len = fgetl (fp, line_buf);
10844
10845 if (line_len == 0) continue;
10846
10847 char *hash_buf = NULL;
10848 int hash_len = 0;
10849
10850 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10851
10852 if (username)
10853 {
10854 char *user_buf = NULL;
10855 int user_len = 0;
10856
10857 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10858
10859 if (remove || show)
10860 {
10861 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10862
10863 *user = (user_t *) malloc (sizeof (user_t));
10864
10865 user_t *user_ptr = *user;
10866
10867 if (user_buf != NULL)
10868 {
10869 user_ptr->user_name = mystrdup (user_buf);
10870 }
10871 else
10872 {
10873 user_ptr->user_name = mystrdup ("");
10874 }
10875
10876 user_ptr->user_len = user_len;
10877 }
10878 }
10879
10880 if (opts_type & OPTS_TYPE_HASH_COPY)
10881 {
10882 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10883
10884 hash_info_tmp->orighash = mystrdup (hash_buf);
10885 }
10886
10887 if (isSalted)
10888 {
10889 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10890 }
10891
10892 if (hash_mode == 3000)
10893 {
10894 if (hash_len == 32)
10895 {
10896 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10897
10898 if (parser_status < PARSER_GLOBAL_ZERO)
10899 {
10900 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10901
10902 continue;
10903 }
10904
10905 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10906
10907 hashes_cnt++;
10908
10909 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10910
10911 if (parser_status < PARSER_GLOBAL_ZERO)
10912 {
10913 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10914
10915 continue;
10916 }
10917
10918 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10919
10920 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);
10921
10922 hashes_cnt++;
10923
10924 // show / left
10925
10926 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);
10927 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);
10928 }
10929 else
10930 {
10931 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10932
10933 if (parser_status < PARSER_GLOBAL_ZERO)
10934 {
10935 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10936
10937 continue;
10938 }
10939
10940 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
10941
10942 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10943 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10944
10945 hashes_cnt++;
10946 }
10947 }
10948 else
10949 {
10950 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10951
10952 if (parser_status < PARSER_GLOBAL_ZERO)
10953 {
10954 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10955
10956 continue;
10957 }
10958
10959 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);
10960
10961 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10962 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10963
10964 hashes_cnt++;
10965 }
10966 }
10967
10968 fclose (fp);
10969
10970 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10971
10972 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10973 }
10974 }
10975 else
10976 {
10977 if (isSalted)
10978 {
10979 hashes_buf[0].salt->salt_len = 8;
10980
10981 // special salt handling
10982
10983 switch (hash_mode)
10984 {
10985 case 1500: hashes_buf[0].salt->salt_len = 2;
10986 break;
10987 case 1731: hashes_buf[0].salt->salt_len = 4;
10988 break;
10989 case 2410: hashes_buf[0].salt->salt_len = 4;
10990 break;
10991 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10992 break;
10993 case 3100: hashes_buf[0].salt->salt_len = 1;
10994 break;
10995 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10996 break;
10997 case 5800: hashes_buf[0].salt->salt_len = 16;
10998 break;
10999 case 6800: hashes_buf[0].salt->salt_len = 32;
11000 break;
11001 case 8400: hashes_buf[0].salt->salt_len = 40;
11002 break;
11003 case 8800: hashes_buf[0].salt->salt_len = 16;
11004 break;
11005 case 8900: hashes_buf[0].salt->salt_len = 16;
11006 hashes_buf[0].salt->scrypt_N = 1024;
11007 hashes_buf[0].salt->scrypt_r = 1;
11008 hashes_buf[0].salt->scrypt_p = 1;
11009 break;
11010 case 9100: hashes_buf[0].salt->salt_len = 16;
11011 break;
11012 case 9300: hashes_buf[0].salt->salt_len = 14;
11013 hashes_buf[0].salt->scrypt_N = 16384;
11014 hashes_buf[0].salt->scrypt_r = 1;
11015 hashes_buf[0].salt->scrypt_p = 1;
11016 break;
11017 case 9400: hashes_buf[0].salt->salt_len = 16;
11018 break;
11019 case 9500: hashes_buf[0].salt->salt_len = 16;
11020 break;
11021 case 9600: hashes_buf[0].salt->salt_len = 16;
11022 break;
11023 case 9700: hashes_buf[0].salt->salt_len = 16;
11024 break;
11025 case 9710: hashes_buf[0].salt->salt_len = 16;
11026 break;
11027 case 9720: hashes_buf[0].salt->salt_len = 16;
11028 break;
11029 case 9800: hashes_buf[0].salt->salt_len = 16;
11030 break;
11031 case 9810: hashes_buf[0].salt->salt_len = 16;
11032 break;
11033 case 9820: hashes_buf[0].salt->salt_len = 16;
11034 break;
11035 case 10300: hashes_buf[0].salt->salt_len = 12;
11036 break;
11037 case 11500: hashes_buf[0].salt->salt_len = 4;
11038 break;
11039 case 11600: hashes_buf[0].salt->salt_len = 4;
11040 break;
11041 case 12400: hashes_buf[0].salt->salt_len = 4;
11042 break;
11043 case 12500: hashes_buf[0].salt->salt_len = 8;
11044 break;
11045 case 12600: hashes_buf[0].salt->salt_len = 64;
11046 break;
11047 }
11048
11049 // special esalt handling
11050
11051 switch (hash_mode)
11052 {
11053 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11054 break;
11055 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11056 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11057 break;
11058 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11059 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11060 break;
11061 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11062 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11063 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11064 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11065 break;
11066 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11067 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11068 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11069 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11070 break;
11071 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11072 break;
11073 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11074 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11075 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11076 break;
11077 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11078 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11079 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11080 break;
11081 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11082 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11083 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11084 break;
11085 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11086 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11087 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11088 break;
11089 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11090 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11091 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11092 break;
11093 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11094 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11095 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11096 break;
11097 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11098 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11099 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11100 break;
11101 }
11102 }
11103
11104 // set hashfile
11105
11106 switch (hash_mode)
11107 {
11108 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11109 break;
11110 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11111 break;
11112 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11113 break;
11114 case 6211:
11115 case 6212:
11116 case 6213:
11117 case 6221:
11118 case 6222:
11119 case 6223:
11120 case 6231:
11121 case 6232:
11122 case 6233:
11123 case 6241:
11124 case 6242:
11125 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11126 break;
11127 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11128 break;
11129 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11130 break;
11131 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11132 break;
11133 }
11134
11135 // set default iterations
11136
11137 switch (hash_mode)
11138 {
11139 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11140 break;
11141 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11142 break;
11143 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11144 break;
11145 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11146 break;
11147 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11148 break;
11149 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11150 break;
11151 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11152 break;
11153 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11154 break;
11155 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11156 break;
11157 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11158 break;
11159 case 6211:
11160 case 6212:
11161 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11162 break;
11163 case 6221:
11164 case 6222:
11165 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11166 break;
11167 case 6231:
11168 case 6232:
11169 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11170 break;
11171 case 6241:
11172 case 6242:
11173 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11174 break;
11175 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11176 break;
11177 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11178 break;
11179 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11180 break;
11181 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11182 break;
11183 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11184 break;
11185 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11186 break;
11187 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11188 break;
11189 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11190 break;
11191 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11192 break;
11193 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11194 break;
11195 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11196 break;
11197 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11198 break;
11199 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11200 break;
11201 case 8900: hashes_buf[0].salt->salt_iter = 1;
11202 break;
11203 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11204 break;
11205 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11206 break;
11207 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11208 break;
11209 case 9300: hashes_buf[0].salt->salt_iter = 1;
11210 break;
11211 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11212 break;
11213 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11214 break;
11215 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11216 break;
11217 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11218 break;
11219 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11220 break;
11221 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11222 break;
11223 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11224 break;
11225 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11226 break;
11227 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11228 break;
11229 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11230 break;
11231 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11232 break;
11233 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11234 break;
11235 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11236 break;
11237 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11238 break;
11239 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11240 break;
11241 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11242 break;
11243 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11244 break;
11245 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11246 break;
11247 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11248 break;
11249 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11250 break;
11251 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11252 break;
11253 }
11254
11255 // set special tuning for benchmark-mode 1
11256
11257 if (benchmark_mode == 1)
11258 {
11259 kernel_loops *= 8;
11260 kernel_accel *= 4;
11261
11262 switch (hash_mode)
11263 {
11264 case 400: kernel_loops = ROUNDS_PHPASS;
11265 kernel_accel = 32;
11266 break;
11267 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11268 kernel_accel = 32;
11269 break;
11270 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11271 kernel_accel = 32;
11272 break;
11273 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11274 kernel_accel = 32;
11275 break;
11276 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11277 kernel_accel = 16;
11278 break;
11279 case 2100: kernel_loops = ROUNDS_DCC2;
11280 kernel_accel = 16;
11281 break;
11282 case 2500: kernel_loops = ROUNDS_WPA2;
11283 kernel_accel = 32;
11284 break;
11285 case 3200: kernel_loops = ROUNDS_BCRYPT;
11286 kernel_accel = 8;
11287 break;
11288 case 5200: kernel_loops = ROUNDS_PSAFE3;
11289 kernel_accel = 16;
11290 break;
11291 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11292 kernel_accel = 16;
11293 break;
11294 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11295 kernel_accel = 64;
11296 break;
11297 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11298 kernel_accel = 32;
11299 break;
11300 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11301 kernel_accel = 32;
11302 break;
11303 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11304 kernel_accel = 8;
11305 break;
11306 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11307 kernel_accel = 8;
11308 break;
11309 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11310 kernel_accel = 8;
11311 break;
11312 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11313 kernel_accel = 8;
11314 break;
11315 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11316 kernel_accel = 8;
11317 break;
11318 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11319 kernel_accel = 8;
11320 break;
11321 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11322 kernel_accel = 128;
11323 break;
11324 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11325 kernel_accel = 64;
11326 break;
11327 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11328 kernel_accel = 64;
11329 break;
11330 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11331 kernel_accel = 32;
11332 break;
11333 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11334 kernel_accel = 128;
11335 break;
11336 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11337 kernel_accel = 128;
11338 break;
11339 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11340 kernel_accel = 32;
11341 break;
11342 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11343 kernel_accel = 64;
11344 break;
11345 case 6800: kernel_loops = ROUNDS_LASTPASS;
11346 kernel_accel = 64;
11347 break;
11348 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11349 kernel_accel = 8;
11350 break;
11351 case 7200: kernel_loops = ROUNDS_GRUB;
11352 kernel_accel = 16;
11353 break;
11354 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11355 kernel_accel = 8;
11356 break;
11357 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11358 kernel_accel = 8;
11359 break;
11360 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11361 kernel_accel = 8;
11362 break;
11363 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11364 kernel_accel = 32;
11365 break;
11366 case 8900: kernel_loops = 1;
11367 kernel_accel = 64;
11368 break;
11369 case 9000: kernel_loops = ROUNDS_PSAFE2;
11370 kernel_accel = 16;
11371 break;
11372 case 9100: kernel_loops = ROUNDS_LOTUS8;
11373 kernel_accel = 64;
11374 break;
11375 case 9200: kernel_loops = ROUNDS_CISCO8;
11376 kernel_accel = 8;
11377 break;
11378 case 9300: kernel_loops = 1;
11379 kernel_accel = 4;
11380 break;
11381 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11382 kernel_accel = 32;
11383 break;
11384 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11385 kernel_accel = 32;
11386 break;
11387 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11388 kernel_accel = 8;
11389 break;
11390 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11391 kernel_accel = 8;
11392 break;
11393 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11394 kernel_accel = 16;
11395 break;
11396 case 10500: kernel_loops = ROUNDS_PDF14;
11397 kernel_accel = 256;
11398 break;
11399 case 10700: kernel_loops = ROUNDS_PDF17L8;
11400 kernel_accel = 8;
11401 break;
11402 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11403 kernel_accel = 8;
11404 break;
11405 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11406 kernel_accel = 8;
11407 break;
11408 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11409 kernel_accel = 8;
11410 break;
11411 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11412 kernel_accel = 8;
11413 break;
11414 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11415 kernel_accel = 8;
11416 break;
11417 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11418 kernel_accel = 8;
11419 break;
11420 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11421 kernel_accel = 8;
11422 break;
11423 case 12300: kernel_loops = ROUNDS_ORACLET;
11424 kernel_accel = 8;
11425 break;
11426 case 12500: kernel_loops = ROUNDS_RAR3;
11427 kernel_accel = 32;
11428 break;
11429 case 12700: kernel_loops = ROUNDS_MYWALLET;
11430 kernel_accel = 512;
11431 break;
11432 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11433 kernel_accel = 512;
11434 break;
11435 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11436 kernel_accel = 8;
11437 break;
11438 case 13000: kernel_loops = ROUNDS_RAR5;
11439 kernel_accel = 8;
11440 break;
11441 }
11442
11443 // some algorithm collide too fast, make that impossible
11444
11445 switch (hash_mode)
11446 {
11447 case 11500: ((uint *) digests_buf)[1] = 1;
11448 break;
11449 }
11450
11451 if (kernel_loops > 1024) kernel_loops = 1024;
11452 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11453 }
11454
11455 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11456 {
11457 kernel_loops = 1024;
11458 }
11459
11460 if (hash_mode == 12500)
11461 {
11462 kernel_loops = ROUNDS_RAR3 / 16;
11463 }
11464
11465 data.kernel_accel = kernel_accel;
11466 data.kernel_loops = kernel_loops;
11467
11468 hashes_cnt = 1;
11469 }
11470
11471 if (show == 1 || left == 1)
11472 {
11473 for (uint i = 0; i < pot_cnt; i++)
11474 {
11475 pot_t *pot_ptr = &pot[i];
11476
11477 hash_t *hashes_buf = &pot_ptr->hash;
11478
11479 local_free (hashes_buf->digest);
11480
11481 if (isSalted)
11482 {
11483 local_free (hashes_buf->salt);
11484 }
11485 }
11486
11487 local_free (pot);
11488
11489 if (data.quiet == 0) log_info_nn ("");
11490
11491 return (0);
11492 }
11493
11494 if (keyspace == 0)
11495 {
11496 if (hashes_cnt == 0)
11497 {
11498 log_error ("ERROR: No hashes loaded");
11499
11500 return (-1);
11501 }
11502 }
11503
11504 /**
11505 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11506 */
11507
11508 if (data.outfile != NULL)
11509 {
11510 if (data.hashfile != NULL)
11511 {
11512 #ifdef _POSIX
11513 struct stat tmpstat_outfile;
11514 struct stat tmpstat_hashfile;
11515 #endif
11516
11517 #ifdef _WIN
11518 struct stat64 tmpstat_outfile;
11519 struct stat64 tmpstat_hashfile;
11520 #endif
11521
11522 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11523
11524 if (tmp_outfile_fp)
11525 {
11526 #ifdef _POSIX
11527 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11528 #endif
11529
11530 #ifdef _WIN
11531 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11532 #endif
11533
11534 fclose (tmp_outfile_fp);
11535 }
11536
11537 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11538
11539 if (tmp_hashfile_fp)
11540 {
11541 #ifdef _POSIX
11542 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11543 #endif
11544
11545 #ifdef _WIN
11546 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11547 #endif
11548
11549 fclose (tmp_hashfile_fp);
11550 }
11551
11552 if (tmp_outfile_fp && tmp_outfile_fp)
11553 {
11554 tmpstat_outfile.st_mode = 0;
11555 tmpstat_outfile.st_nlink = 0;
11556 tmpstat_outfile.st_uid = 0;
11557 tmpstat_outfile.st_gid = 0;
11558 tmpstat_outfile.st_rdev = 0;
11559 tmpstat_outfile.st_atime = 0;
11560
11561 tmpstat_hashfile.st_mode = 0;
11562 tmpstat_hashfile.st_nlink = 0;
11563 tmpstat_hashfile.st_uid = 0;
11564 tmpstat_hashfile.st_gid = 0;
11565 tmpstat_hashfile.st_rdev = 0;
11566 tmpstat_hashfile.st_atime = 0;
11567
11568 #ifdef _POSIX
11569 tmpstat_outfile.st_blksize = 0;
11570 tmpstat_outfile.st_blocks = 0;
11571
11572 tmpstat_hashfile.st_blksize = 0;
11573 tmpstat_hashfile.st_blocks = 0;
11574 #endif
11575
11576 #ifdef _POSIX
11577 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11578 {
11579 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11580
11581 return (-1);
11582 }
11583 #endif
11584
11585 #ifdef _WIN
11586 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11587 {
11588 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11589
11590 return (-1);
11591 }
11592 #endif
11593 }
11594 }
11595 }
11596
11597 /**
11598 * Remove duplicates
11599 */
11600
11601 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11602
11603 if (isSalted)
11604 {
11605 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11606 }
11607 else
11608 {
11609 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11610 }
11611
11612 uint hashes_cnt_orig = hashes_cnt;
11613
11614 hashes_cnt = 1;
11615
11616 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11617 {
11618 if (isSalted)
11619 {
11620 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11621 {
11622 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11623 }
11624 }
11625 else
11626 {
11627 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11628 }
11629
11630 if (hashes_pos > hashes_cnt)
11631 {
11632 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11633 }
11634
11635 hashes_cnt++;
11636 }
11637
11638 /**
11639 * Potfile removes
11640 */
11641
11642 uint potfile_remove_cracks = 0;
11643
11644 if (potfile_disable == 0)
11645 {
11646 hash_t hash_buf;
11647
11648 hash_buf.digest = mymalloc (dgst_size);
11649 hash_buf.salt = NULL;
11650 hash_buf.esalt = NULL;
11651 hash_buf.hash_info = NULL;
11652 hash_buf.cracked = 0;
11653
11654 if (isSalted)
11655 {
11656 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11657 }
11658
11659 if (esalt_size)
11660 {
11661 hash_buf.esalt = mymalloc (esalt_size);
11662 }
11663
11664 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11665
11666 // no solution for these special hash types (for instane because they use hashfile in output etc)
11667 if ((hash_mode != 5200) &&
11668 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11669 (hash_mode != 9000))
11670 {
11671 FILE *fp = fopen (potfile, "rb");
11672
11673 if (fp != NULL)
11674 {
11675 while (!feof (fp))
11676 {
11677 char line_buf[BUFSIZ];
11678
11679 memset (line_buf, 0, BUFSIZ);
11680
11681 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11682
11683 if (ptr == NULL) break;
11684
11685 int line_len = strlen (line_buf);
11686
11687 if (line_len == 0) continue;
11688
11689 int iter = MAX_CUT_TRIES;
11690
11691 for (int i = line_len - 1; i && iter; i--, line_len--)
11692 {
11693 if (line_buf[i] != ':') continue;
11694
11695 if (isSalted)
11696 {
11697 memset (hash_buf.salt, 0, sizeof (salt_t));
11698 }
11699
11700 hash_t *found = NULL;
11701
11702 if (hash_mode == 6800)
11703 {
11704 if (i < 48) // 48 = 12 * uint in salt_buf[]
11705 {
11706 // manipulate salt_buf
11707 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11708
11709 hash_buf.salt->salt_len = i;
11710
11711 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11712 }
11713 }
11714 else if (hash_mode == 2500)
11715 {
11716 if (i < 48) // 48 = 12 * uint in salt_buf[]
11717 {
11718 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11719 // manipulate salt_buf
11720
11721 // to be safe work with a copy (because of line_len loop, i etc)
11722
11723 char line_buf_cpy[BUFSIZ];
11724 memset (line_buf_cpy, 0, BUFSIZ);
11725
11726 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11727
11728 memcpy (line_buf_cpy, line_buf, i);
11729
11730 char *mac2_pos = strrchr (line_buf_cpy, ':');
11731
11732 if (mac2_pos == NULL) continue;
11733
11734 mac2_pos[0] = 0;
11735 mac2_pos++;
11736
11737 if (strlen (mac2_pos) != 12) continue;
11738
11739 char *mac1_pos = strrchr (line_buf_cpy, ':');
11740
11741 if (mac1_pos == NULL) continue;
11742
11743 mac1_pos[0] = 0;
11744 mac1_pos++;
11745
11746 if (strlen (mac1_pos) != 12) continue;
11747
11748 uint essid_length = mac1_pos - line_buf_cpy - 1;
11749
11750 // here we need the ESSID
11751 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11752
11753 hash_buf.salt->salt_len = essid_length;
11754
11755 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11756
11757 if (found)
11758 {
11759 wpa_t *wpa = (wpa_t *) found->esalt;
11760
11761 uint pke[25];
11762
11763 char *pke_ptr = (char *) pke;
11764
11765 for (uint i = 0; i < 25; i++)
11766 {
11767 pke[i] = byte_swap_32 (wpa->pke[i]);
11768 }
11769
11770 u8 mac1[6];
11771 u8 mac2[6];
11772
11773 memcpy (mac1, pke_ptr + 23, 6);
11774 memcpy (mac2, pke_ptr + 29, 6);
11775
11776 // compare hex string(s) vs binary MAC address(es)
11777
11778 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11779 {
11780 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11781 {
11782 found = NULL;
11783 break;
11784 }
11785 }
11786
11787 // early skip ;)
11788 if (!found) continue;
11789
11790 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11791 {
11792 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11793 {
11794 found = NULL;
11795 break;
11796 }
11797 }
11798 }
11799 }
11800 }
11801 else
11802 {
11803 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11804
11805 if (parser_status == PARSER_OK)
11806 {
11807 if (isSalted)
11808 {
11809 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11810 }
11811 else
11812 {
11813 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11814 }
11815 }
11816 }
11817
11818 if (found == NULL) continue;
11819
11820 if (!found->cracked) potfile_remove_cracks++;
11821
11822 found->cracked = 1;
11823
11824 if (found) break;
11825
11826 iter--;
11827 }
11828 }
11829
11830 fclose (fp);
11831 }
11832 }
11833
11834 if (esalt_size)
11835 {
11836 local_free (hash_buf.esalt);
11837 }
11838
11839 if (isSalted)
11840 {
11841 local_free (hash_buf.salt);
11842 }
11843
11844 local_free (hash_buf.digest);
11845 }
11846
11847 /**
11848 * Now generate all the buffers required for later
11849 */
11850
11851 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11852
11853 salt_t *salts_buf_new = NULL;
11854 void *esalts_buf_new = NULL;
11855
11856 if (isSalted)
11857 {
11858 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11859
11860 if (esalt_size)
11861 {
11862 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11863 }
11864 }
11865 else
11866 {
11867 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11868 }
11869
11870 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11871
11872 uint digests_cnt = hashes_cnt;
11873 uint digests_done = 0;
11874
11875 uint size_digests = digests_cnt * dgst_size;
11876 uint size_shown = digests_cnt * sizeof (uint);
11877
11878 uint *digests_shown = (uint *) mymalloc (size_shown);
11879 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11880
11881 uint salts_cnt = 0;
11882 uint salts_done = 0;
11883
11884 hashinfo_t **hash_info = NULL;
11885
11886 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11887 {
11888 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11889
11890 if (username && (remove || show))
11891 {
11892 uint user_pos;
11893
11894 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11895 {
11896 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11897
11898 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11899 }
11900 }
11901 }
11902
11903 uint *salts_shown = (uint *) mymalloc (size_shown);
11904
11905 salt_t *salt_buf;
11906
11907 {
11908 // copied from inner loop
11909
11910 salt_buf = &salts_buf_new[salts_cnt];
11911
11912 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11913
11914 if (esalt_size)
11915 {
11916 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11917 }
11918
11919 salt_buf->digests_cnt = 0;
11920 salt_buf->digests_done = 0;
11921 salt_buf->digests_offset = 0;
11922
11923 salts_cnt++;
11924 }
11925
11926 if (hashes_buf[0].cracked == 1)
11927 {
11928 digests_shown[0] = 1;
11929
11930 digests_done++;
11931
11932 salt_buf->digests_done++;
11933 }
11934
11935 salt_buf->digests_cnt++;
11936
11937 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11938
11939 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11940 {
11941 hash_info[0] = hashes_buf[0].hash_info;
11942 }
11943
11944 // copy from inner loop
11945
11946 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11947 {
11948 if (isSalted)
11949 {
11950 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11951 {
11952 salt_buf = &salts_buf_new[salts_cnt];
11953
11954 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11955
11956 if (esalt_size)
11957 {
11958 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11959 }
11960
11961 salt_buf->digests_cnt = 0;
11962 salt_buf->digests_done = 0;
11963 salt_buf->digests_offset = hashes_pos;
11964
11965 salts_cnt++;
11966 }
11967 }
11968
11969 if (hashes_buf[hashes_pos].cracked == 1)
11970 {
11971 digests_shown[hashes_pos] = 1;
11972
11973 digests_done++;
11974
11975 salt_buf->digests_done++;
11976 }
11977
11978 salt_buf->digests_cnt++;
11979
11980 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11981
11982 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11983 {
11984 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11985 }
11986 }
11987
11988 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11989 {
11990 salt_t *salt_buf = &salts_buf_new[salt_pos];
11991
11992 if (salt_buf->digests_done == salt_buf->digests_cnt)
11993 {
11994 salts_shown[salt_pos] = 1;
11995
11996 salts_done++;
11997 }
11998
11999 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12000 }
12001
12002 local_free (digests_buf);
12003 local_free (salts_buf);
12004 local_free (esalts_buf);
12005
12006 digests_buf = digests_buf_new;
12007 salts_buf = salts_buf_new;
12008 esalts_buf = esalts_buf_new;
12009
12010 local_free (hashes_buf);
12011
12012 /**
12013 * special modification not set from parser
12014 */
12015
12016 switch (hash_mode)
12017 {
12018 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12019 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12020 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12021 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12022 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12023 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12024 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12025 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12026 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12027 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12028 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12029 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12030 }
12031
12032 if (truecrypt_keyfiles)
12033 {
12034 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12035
12036 char *keyfiles = strdup (truecrypt_keyfiles);
12037
12038 char *keyfile = strtok (keyfiles, ",");
12039
12040 do
12041 {
12042 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12043
12044 } while ((keyfile = strtok (NULL, ",")) != NULL);
12045
12046 free (keyfiles);
12047 }
12048
12049 data.digests_cnt = digests_cnt;
12050 data.digests_done = digests_done;
12051 data.digests_buf = digests_buf;
12052 data.digests_shown = digests_shown;
12053 data.digests_shown_tmp = digests_shown_tmp;
12054
12055 data.salts_cnt = salts_cnt;
12056 data.salts_done = salts_done;
12057 data.salts_buf = salts_buf;
12058 data.salts_shown = salts_shown;
12059
12060 data.esalts_buf = esalts_buf;
12061 data.hash_info = hash_info;
12062
12063 /**
12064 * Automatic Optimizers
12065 */
12066
12067 if (salts_cnt == 1)
12068 opti_type |= OPTI_TYPE_SINGLE_SALT;
12069
12070 if (digests_cnt == 1)
12071 opti_type |= OPTI_TYPE_SINGLE_HASH;
12072
12073 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12074 opti_type |= OPTI_TYPE_NOT_ITERATED;
12075
12076 if (attack_mode == ATTACK_MODE_BF)
12077 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12078
12079 data.opti_type = opti_type;
12080
12081 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12082 {
12083 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12084 {
12085 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12086 {
12087 if (opts_type & OPTS_TYPE_ST_ADD80)
12088 {
12089 opts_type &= ~OPTS_TYPE_ST_ADD80;
12090 opts_type |= OPTS_TYPE_PT_ADD80;
12091 }
12092
12093 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12094 {
12095 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12096 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12097 }
12098
12099 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12100 {
12101 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12102 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12103 }
12104 }
12105 }
12106 }
12107
12108 /**
12109 * Some algorithm, like descrypt, can benefit from JIT compilation
12110 */
12111
12112 int force_jit_compilation = -1;
12113
12114 if (hash_mode == 8900)
12115 {
12116 force_jit_compilation = 8900;
12117 }
12118 else if (hash_mode == 9300)
12119 {
12120 force_jit_compilation = 8900;
12121 }
12122 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12123 {
12124 force_jit_compilation = 1500;
12125 }
12126
12127 /**
12128 * generate bitmap tables
12129 */
12130
12131 const uint bitmap_shift1 = 5;
12132 const uint bitmap_shift2 = 13;
12133
12134 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12135
12136 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12137 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12138 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12139 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12140 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12141 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12142 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12143 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12144
12145 uint bitmap_bits;
12146 uint bitmap_nums;
12147 uint bitmap_mask;
12148 uint bitmap_size;
12149
12150 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12151 {
12152 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12153
12154 bitmap_nums = 1 << bitmap_bits;
12155
12156 bitmap_mask = bitmap_nums - 1;
12157
12158 bitmap_size = bitmap_nums * sizeof (uint);
12159
12160 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12161
12162 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;
12163 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;
12164
12165 break;
12166 }
12167
12168 bitmap_nums = 1 << bitmap_bits;
12169
12170 bitmap_mask = bitmap_nums - 1;
12171
12172 bitmap_size = bitmap_nums * sizeof (uint);
12173
12174 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);
12175 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);
12176
12177 /**
12178 * prepare quick rule
12179 */
12180
12181 data.rule_buf_l = rule_buf_l;
12182 data.rule_buf_r = rule_buf_r;
12183
12184 int rule_len_l = (int) strlen (rule_buf_l);
12185 int rule_len_r = (int) strlen (rule_buf_r);
12186
12187 data.rule_len_l = rule_len_l;
12188 data.rule_len_r = rule_len_r;
12189
12190 /**
12191 * load rules
12192 */
12193
12194 uint *all_kernel_rules_cnt = NULL;
12195
12196 kernel_rule_t **all_kernel_rules_buf = NULL;
12197
12198 if (rp_files_cnt)
12199 {
12200 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12201
12202 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12203 }
12204
12205 char rule_buf[BUFSIZ];
12206
12207 int rule_len = 0;
12208
12209 for (uint i = 0; i < rp_files_cnt; i++)
12210 {
12211 uint kernel_rules_avail = 0;
12212
12213 uint kernel_rules_cnt = 0;
12214
12215 kernel_rule_t *kernel_rules_buf = NULL;
12216
12217 char *rp_file = rp_files[i];
12218
12219 char in[BLOCK_SIZE];
12220 char out[BLOCK_SIZE];
12221
12222 FILE *fp = NULL;
12223
12224 uint rule_line = 0;
12225
12226 if ((fp = fopen (rp_file, "rb")) == NULL)
12227 {
12228 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12229
12230 return (-1);
12231 }
12232
12233 while (!feof (fp))
12234 {
12235 memset (rule_buf, 0, BUFSIZ);
12236
12237 rule_len = fgetl (fp, rule_buf);
12238
12239 rule_line++;
12240
12241 if (rule_len == 0) continue;
12242
12243 if (rule_buf[0] == '#') continue;
12244
12245 if (kernel_rules_avail == kernel_rules_cnt)
12246 {
12247 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12248
12249 kernel_rules_avail += INCR_RULES;
12250 }
12251
12252 memset (in, 0, BLOCK_SIZE);
12253 memset (out, 0, BLOCK_SIZE);
12254
12255 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12256
12257 if (result == -1)
12258 {
12259 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12260
12261 continue;
12262 }
12263
12264 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12265 {
12266 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12267
12268 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12269
12270 continue;
12271 }
12272
12273 /* its so slow
12274 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12275 {
12276 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12277
12278 continue;
12279 }
12280 */
12281
12282 kernel_rules_cnt++;
12283 }
12284
12285 fclose (fp);
12286
12287 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12288
12289 all_kernel_rules_buf[i] = kernel_rules_buf;
12290 }
12291
12292 /**
12293 * merge rules or automatic rule generator
12294 */
12295
12296 uint kernel_rules_cnt = 0;
12297
12298 kernel_rule_t *kernel_rules_buf = NULL;
12299
12300 if (attack_mode == ATTACK_MODE_STRAIGHT)
12301 {
12302 if (rp_files_cnt)
12303 {
12304 kernel_rules_cnt = 1;
12305
12306 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12307
12308 repeats[0] = kernel_rules_cnt;
12309
12310 for (uint i = 0; i < rp_files_cnt; i++)
12311 {
12312 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12313
12314 repeats[i + 1] = kernel_rules_cnt;
12315 }
12316
12317 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12318
12319 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12320
12321 for (uint i = 0; i < kernel_rules_cnt; i++)
12322 {
12323 uint out_pos = 0;
12324
12325 kernel_rule_t *out = &kernel_rules_buf[i];
12326
12327 for (uint j = 0; j < rp_files_cnt; j++)
12328 {
12329 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12330 uint in_pos;
12331
12332 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12333
12334 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12335 {
12336 if (out_pos == RULES_MAX - 1)
12337 {
12338 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12339
12340 break;
12341 }
12342
12343 out->cmds[out_pos] = in->cmds[in_pos];
12344 }
12345 }
12346 }
12347
12348 local_free (repeats);
12349 }
12350 else if (rp_gen)
12351 {
12352 uint kernel_rules_avail = 0;
12353
12354 while (kernel_rules_cnt < rp_gen)
12355 {
12356 if (kernel_rules_avail == kernel_rules_cnt)
12357 {
12358 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12359
12360 kernel_rules_avail += INCR_RULES;
12361 }
12362
12363 memset (rule_buf, 0, BLOCK_SIZE);
12364
12365 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12366
12367 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12368
12369 kernel_rules_cnt++;
12370 }
12371 }
12372 }
12373
12374 /**
12375 * generate NOP rules
12376 */
12377
12378 if (kernel_rules_cnt == 0)
12379 {
12380 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12381
12382 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12383
12384 kernel_rules_cnt++;
12385 }
12386
12387 data.kernel_rules_cnt = kernel_rules_cnt;
12388 data.kernel_rules_buf = kernel_rules_buf;
12389
12390 /**
12391 * OpenCL platforms: detect
12392 */
12393
12394 cl_platform_id platforms[CL_PLATFORMS_MAX];
12395
12396 cl_uint platforms_cnt = 0;
12397
12398 cl_device_id platform_devices[DEVICES_MAX];
12399
12400 cl_uint platform_devices_cnt;
12401
12402 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12403
12404 if (platforms_cnt == 0)
12405 {
12406 log_error ("ERROR: No OpenCL compatible platform found");
12407
12408 return (-1);
12409 }
12410
12411 /**
12412 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12413 */
12414
12415 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12416 {
12417 cl_platform_id platform = platforms[platform_id];
12418
12419 char platform_vendor[INFOSZ] = { 0 };
12420
12421 hc_clGetPlatformInfo (platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12422
12423 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12424 {
12425 // make sure that we do not directly control the fan for NVidia
12426
12427 gpu_temp_retain = 0;
12428
12429 data.gpu_temp_retain = gpu_temp_retain;
12430 }
12431 }
12432
12433 /**
12434 * OpenCL devices: simply push all devices from all platforms into the same device array
12435 */
12436
12437 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12438
12439 data.devices_param = devices_param;
12440
12441 uint devices_cnt = 0;
12442
12443 uint devices_active = 0;
12444
12445 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12446 {
12447 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12448
12449 cl_platform_id platform = platforms[platform_id];
12450
12451 hc_clGetDeviceIDs (platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12452
12453 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12454 {
12455 const uint device_id = devices_cnt;
12456
12457 hc_device_param_t *device_param = &data.devices_param[device_id];
12458
12459 device_param->device = platform_devices[platform_devices_id];
12460
12461 device_param->device_id = device_id;
12462
12463 device_param->platform_devices_id = platform_devices_id;
12464
12465 // vendor_id
12466
12467 cl_uint vendor_id = 0;
12468
12469 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12470
12471 device_param->vendor_id = vendor_id;
12472
12473 // device_type
12474
12475 cl_device_type device_type;
12476
12477 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12478
12479 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12480
12481 device_param->device_type = device_type;
12482
12483 // device_name
12484
12485 char *device_name = (char *) mymalloc (INFOSZ);
12486
12487 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_NAME, INFOSZ, device_name, NULL);
12488
12489 device_param->device_name = device_name;
12490
12491 // device_version
12492
12493 char *device_version = (char *) mymalloc (INFOSZ);
12494
12495 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_VERSION, INFOSZ, device_version, NULL);
12496
12497 device_param->device_version = device_version;
12498
12499 if (strstr (device_version, "pocl"))
12500 {
12501 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12502 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12503
12504 cl_uint vendor_id = 0xffff;
12505
12506 device_param->vendor_id = vendor_id;
12507 }
12508
12509 // max_compute_units
12510
12511 cl_uint vector_width;
12512
12513 if (attack_mode == ATTACK_MODE_BF)
12514 {
12515 if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
12516 {
12517 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12518 }
12519 else
12520 {
12521 vector_width = opencl_vector_width;
12522 }
12523 }
12524 else
12525 {
12526 vector_width = 1;
12527 }
12528
12529 if (vector_width > 8) vector_width = 8;
12530
12531 device_param->vector_width = vector_width;
12532
12533 // max_compute_units
12534
12535 cl_uint device_processors;
12536
12537 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12538
12539 device_param->device_processors = device_processors;
12540
12541 // max_mem_alloc_size
12542
12543 cl_ulong device_maxmem_alloc;
12544
12545 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12546
12547 device_param->device_maxmem_alloc = device_maxmem_alloc;
12548
12549 // max_mem_alloc_size
12550
12551 cl_ulong device_global_mem;
12552
12553 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12554
12555 device_param->device_global_mem = device_global_mem;
12556
12557 // max_clock_frequency
12558
12559 cl_uint device_maxclock_frequency;
12560
12561 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12562
12563 device_param->device_maxclock_frequency = device_maxclock_frequency;
12564
12565 // skipped
12566
12567 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12568 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12569
12570 device_param->skipped = (skipped1 || skipped2);
12571
12572 // driver_version
12573
12574 char *driver_version = (char *) mymalloc (INFOSZ);
12575
12576 hc_clGetDeviceInfo (device_param->device, CL_DRIVER_VERSION, INFOSZ, driver_version, NULL);
12577
12578 device_param->driver_version = driver_version;
12579
12580 // device_name_chksum
12581
12582 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12583
12584 #if __x86_64__
12585 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 64, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12586 #else
12587 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 32, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12588 #endif
12589
12590 uint device_name_digest[4];
12591
12592 device_name_digest[0] = 0;
12593 device_name_digest[1] = 0;
12594 device_name_digest[2] = 0;
12595 device_name_digest[3] = 0;
12596
12597 md5_64 ((uint *) device_name_chksum, device_name_digest);
12598
12599 sprintf (device_name_chksum, "%08x", device_name_digest[0]);
12600
12601 device_param->device_name_chksum = device_name_chksum;
12602
12603 // device_processor_cores
12604
12605 if (device_type & CL_DEVICE_TYPE_CPU)
12606 {
12607 cl_uint device_processor_cores = 1;
12608
12609 device_param->device_processor_cores = device_processor_cores;
12610 }
12611
12612 if (device_type & CL_DEVICE_TYPE_GPU)
12613 {
12614 if (vendor_id == VENDOR_ID_AMD)
12615 {
12616 cl_uint device_processor_cores = 0;
12617
12618 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12619
12620 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12621
12622 device_param->device_processor_cores = device_processor_cores;
12623 }
12624 else if (vendor_id == VENDOR_ID_NV)
12625 {
12626 cl_uint kernel_exec_timeout = 0;
12627
12628 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12629
12630 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12631
12632 device_param->kernel_exec_timeout = kernel_exec_timeout;
12633
12634 cl_uint device_processor_cores = 0;
12635
12636 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12637
12638 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12639
12640 device_param->device_processor_cores = device_processor_cores;
12641
12642 cl_uint sm_minor = 0;
12643 cl_uint sm_major = 0;
12644
12645 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12646 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12647
12648 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12649 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12650
12651 device_param->sm_minor = sm_minor;
12652 device_param->sm_major = sm_major;
12653 }
12654 else
12655 {
12656 cl_uint device_processor_cores = 1;
12657
12658 device_param->device_processor_cores = device_processor_cores;
12659 }
12660 }
12661
12662 // display results
12663
12664 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12665 {
12666 if (device_param->skipped == 0)
12667 {
12668 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12669 device_id + 1,
12670 device_name,
12671 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12672 (unsigned int) (device_global_mem / 1024 / 1024),
12673 (unsigned int) (device_maxclock_frequency),
12674 (unsigned int) device_processors);
12675 }
12676 else
12677 {
12678 log_info ("Device #%u: %s, skipped",
12679 device_id + 1,
12680 device_name);
12681 }
12682 }
12683
12684 // common driver check
12685
12686 if (device_param->skipped == 0)
12687 {
12688 if (strstr (device_version, "pocl"))
12689 {
12690 if (force == 0)
12691 {
12692 log_info ("");
12693 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12694 log_info ("You are STRONGLY encouraged not to use it");
12695 log_info ("You can use --force to override this but do not post error reports if you do so");
12696 log_info ("");
12697
12698 return (-1);
12699 }
12700 }
12701
12702 if (device_type & CL_DEVICE_TYPE_GPU)
12703 {
12704 if (vendor_id == VENDOR_ID_NV)
12705 {
12706 if (device_param->kernel_exec_timeout != 0)
12707 {
12708 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);
12709 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12710 }
12711 }
12712 else if (vendor_id == VENDOR_ID_AMD)
12713 {
12714 int catalyst_check = (force == 1) ? 0 : 1;
12715
12716 int catalyst_warn = 0;
12717
12718 int catalyst_broken = 0;
12719
12720 if (catalyst_check == 1)
12721 {
12722 catalyst_warn = 1;
12723
12724 // v14.9 and higher
12725 if (atoi (device_param->driver_version) >= 1573)
12726 {
12727 catalyst_warn = 0;
12728 }
12729
12730 catalyst_check = 0;
12731 }
12732
12733 if (catalyst_broken == 1)
12734 {
12735 log_info ("");
12736 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12737 log_info ("It will pass over cracked hashes and does not report them as cracked");
12738 log_info ("You are STRONGLY encouraged not to use it");
12739 log_info ("You can use --force to override this but do not post error reports if you do so");
12740 log_info ("");
12741
12742 return (-1);
12743 }
12744
12745 if (catalyst_warn == 1)
12746 {
12747 log_info ("");
12748 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12749 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12750 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12751 #ifdef _WIN
12752 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12753 #endif
12754 log_info ("You can use --force to override this but do not post error reports if you do so");
12755 log_info ("");
12756
12757 return (-1);
12758 }
12759 }
12760 }
12761
12762 devices_active++;
12763 }
12764
12765 // next please
12766
12767 devices_cnt++;
12768 }
12769 }
12770
12771 if (devices_active == 0)
12772 {
12773 log_error ("ERROR: No devices found/left");
12774
12775 return (-1);
12776 }
12777
12778 data.devices_cnt = devices_cnt;
12779
12780 data.devices_active = devices_active;
12781
12782 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12783 {
12784 log_info ("");
12785 }
12786
12787 /**
12788 * OpenCL devices: allocate buffer for device specific information
12789 */
12790
12791 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12792
12793 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12794
12795 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12796
12797 /**
12798 * enable custom signal handler(s)
12799 */
12800
12801 if (benchmark == 0)
12802 {
12803 hc_signal (sigHandler_default);
12804 }
12805 else
12806 {
12807 hc_signal (sigHandler_benchmark);
12808 }
12809
12810 /**
12811 * User-defined GPU temp handling
12812 */
12813
12814 if (gpu_temp_disable == 1)
12815 {
12816 gpu_temp_abort = 0;
12817 gpu_temp_retain = 0;
12818 }
12819
12820 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12821 {
12822 if (gpu_temp_abort < gpu_temp_retain)
12823 {
12824 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12825
12826 return (-1);
12827 }
12828 }
12829
12830 data.gpu_temp_disable = gpu_temp_disable;
12831 data.gpu_temp_abort = gpu_temp_abort;
12832 data.gpu_temp_retain = gpu_temp_retain;
12833
12834 /**
12835 * inform the user
12836 */
12837
12838 if (data.quiet == 0)
12839 {
12840 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12841
12842 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);
12843
12844 if (attack_mode == ATTACK_MODE_STRAIGHT)
12845 {
12846 log_info ("Rules: %u", kernel_rules_cnt);
12847 }
12848
12849 if (opti_type)
12850 {
12851 log_info ("Applicable Optimizers:");
12852
12853 for (uint i = 0; i < 32; i++)
12854 {
12855 const uint opti_bit = 1u << i;
12856
12857 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12858 }
12859 }
12860
12861 /**
12862 * Watchdog and Temperature balance
12863 */
12864
12865 if (gpu_temp_abort == 0)
12866 {
12867 log_info ("Watchdog: Temperature abort trigger disabled");
12868 }
12869 else
12870 {
12871 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12872 }
12873
12874 if (gpu_temp_retain == 0)
12875 {
12876 log_info ("Watchdog: Temperature retain trigger disabled");
12877 }
12878 else
12879 {
12880 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12881 }
12882 }
12883
12884 if (data.quiet == 0) log_info ("");
12885
12886 /**
12887 * HM devices: init
12888 */
12889
12890 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12891 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12892
12893 if (gpu_temp_disable == 0)
12894 {
12895 #ifdef WIN
12896 if (NvAPI_Initialize () == NVAPI_OK)
12897 {
12898 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12899
12900 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12901
12902 int tmp_out = 0;
12903
12904 for (int i = 0; i < tmp_in; i++)
12905 {
12906 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12907 }
12908
12909 for (int i = 0; i < tmp_out; i++)
12910 {
12911 NvU32 speed;
12912
12913 if (NvAPI_GPU_GetTachReading (hm_adapters_nv[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
12914 }
12915 }
12916 #endif
12917
12918 #ifdef LINUX
12919 HM_LIB hm_dll_nv = hm_init (VENDOR_ID_NV);
12920
12921 data.hm_dll_nv = hm_dll_nv;
12922
12923 if (hm_dll_nv)
12924 {
12925 if (hc_NVML_nvmlInit (hm_dll_nv) == NVML_SUCCESS)
12926 {
12927 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12928
12929 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12930
12931 int tmp_out = 0;
12932
12933 for (int i = 0; i < tmp_in; i++)
12934 {
12935 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12936 }
12937
12938 for (int i = 0; i < tmp_out; i++)
12939 {
12940 unsigned int speed;
12941
12942 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;
12943 }
12944 }
12945 }
12946 #endif
12947
12948 HM_LIB hm_dll_amd = hm_init (VENDOR_ID_AMD);
12949
12950 data.hm_dll_amd = hm_dll_amd;
12951
12952 if (hm_dll_amd)
12953 {
12954 if (hc_ADL_Main_Control_Create (hm_dll_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12955 {
12956 // total number of adapters
12957
12958 int hm_adapters_num;
12959
12960 if (get_adapters_num_amd (hm_dll_amd, &hm_adapters_num) != 0) return (-1);
12961
12962 // adapter info
12963
12964 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll_amd, hm_adapters_num);
12965
12966 if (lpAdapterInfo == NULL) return (-1);
12967
12968 // get a list (of ids of) valid/usable adapters
12969
12970 int num_adl_adapters = 0;
12971
12972 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12973
12974 if (num_adl_adapters > 0)
12975 {
12976 hc_thread_mutex_lock (mux_adl);
12977
12978 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
12979
12980 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12981
12982 hm_get_overdrive_version (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12983 hm_check_fanspeed_control (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12984
12985 hc_thread_mutex_unlock (mux_adl);
12986 }
12987
12988 myfree (valid_adl_device_list);
12989 myfree (lpAdapterInfo);
12990 }
12991 }
12992 }
12993
12994 /**
12995 * HM devices: copy
12996 */
12997
12998 if (gpu_temp_disable == 0)
12999 {
13000 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13001 {
13002 hc_device_param_t *device_param = &data.devices_param[device_id];
13003
13004 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13005
13006 if (device_param->skipped) continue;
13007
13008 const uint platform_devices_id = device_param->platform_devices_id;
13009
13010 if (device_param->vendor_id == VENDOR_ID_NV)
13011 {
13012 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13013 }
13014
13015 if (device_param->vendor_id == VENDOR_ID_AMD)
13016 {
13017 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13018 }
13019 }
13020 }
13021
13022 /*
13023 * Temporary fix:
13024 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13025 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13026 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13027 * Driver / ADL bug?
13028 */
13029
13030 if (powertune_enable == 1)
13031 {
13032 hc_thread_mutex_lock (mux_adl);
13033
13034 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13035 {
13036 hc_device_param_t *device_param = &data.devices_param[device_id];
13037
13038 if (device_param->skipped) continue;
13039
13040 if (data.hm_device[device_id].od_version == 6)
13041 {
13042 // set powertune value only
13043
13044 int powertune_supported = 0;
13045
13046 int ADL_rc = 0;
13047
13048 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13049 {
13050 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13051
13052 return (-1);
13053 }
13054
13055 if (powertune_supported != 0)
13056 {
13057 // powertune set
13058 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13059
13060 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13061 {
13062 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13063
13064 return (-1);
13065 }
13066
13067 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13068 {
13069 log_error ("ERROR: Failed to set new ADL PowerControl values");
13070
13071 return (-1);
13072 }
13073 }
13074 }
13075 }
13076
13077 hc_thread_mutex_unlock (mux_adl);
13078 }
13079
13080 uint kernel_blocks_all = 0;
13081
13082 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13083 {
13084 /**
13085 * host buffer
13086 */
13087
13088 hc_device_param_t *device_param = &data.devices_param[device_id];
13089
13090 if (device_param->skipped) continue;
13091
13092 /**
13093 * device properties
13094 */
13095
13096 char *device_name_chksum = device_param->device_name_chksum;
13097
13098 uint device_processors = device_param->device_processors;
13099
13100 uint device_processor_cores = device_param->device_processor_cores;
13101
13102 cl_device_type device_type = device_param->device_type;
13103
13104 /**
13105 * create context for each device
13106 */
13107
13108 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13109
13110 /**
13111 * create command-queue
13112 */
13113
13114 // not support with NV
13115 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13116
13117 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13118
13119 /**
13120 * create input buffers on device
13121 */
13122
13123 uint kernel_threads = KERNEL_THREADS;
13124
13125 // bcrypt
13126 if (hash_mode == 3200) kernel_threads = 8;
13127 if (hash_mode == 9000) kernel_threads = 8;
13128
13129 if (device_type & CL_DEVICE_TYPE_CPU)
13130 {
13131 // CPU still need lots of workitems, don't know why...
13132 // for testing phase, lets start with this
13133
13134 // kernel_accel = 1;
13135 }
13136
13137 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13138 uint kernel_blocks = kernel_power;
13139
13140 device_param->kernel_threads = kernel_threads;
13141 device_param->kernel_power_user = kernel_power;
13142 device_param->kernel_blocks_user = kernel_blocks;
13143
13144 kernel_blocks_all += kernel_blocks;
13145
13146 uint size_pws = kernel_power * sizeof (pw_t);
13147
13148 uint size_tmps = 4;
13149
13150 switch (hash_mode)
13151 {
13152 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13153 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13154 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13155 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13156 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13157 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13158 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13159 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13160 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13161 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13162 case 6211:
13163 case 6212:
13164 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13165 case 6221:
13166 case 6222:
13167 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13168 case 6231:
13169 case 6232:
13170 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13171 case 6241:
13172 case 6242:
13173 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13174 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13175 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13176 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13177 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13178 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13179 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13180 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13181 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13182 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13183 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13184 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13185 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13186 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13187 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13188 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13189 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13190 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13191 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13192 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13193 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13194 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13195 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13196 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13197 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13198 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13199 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13200 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13201 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13202 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13203 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13204 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13205 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13206 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13207 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13208 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13209 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13210 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13211 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13212 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13213 };
13214
13215 uint size_hooks = 4;
13216
13217 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13218 {
13219 // insert correct hook size
13220 }
13221
13222 // we can optimize some stuff here...
13223
13224 device_param->size_pws = size_pws;
13225 device_param->size_tmps = size_tmps;
13226 device_param->size_hooks = size_hooks;
13227
13228 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13229 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13230
13231 device_param->size_root_css = size_root_css;
13232 device_param->size_markov_css = size_markov_css;
13233
13234 uint size_results = KERNEL_THREADS * sizeof (uint);
13235
13236 device_param->size_results = size_results;
13237
13238 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13239 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13240
13241 uint size_plains = digests_cnt * sizeof (plain_t);
13242 uint size_salts = salts_cnt * sizeof (salt_t);
13243 uint size_esalts = salts_cnt * esalt_size;
13244
13245 device_param->size_plains = size_plains;
13246 device_param->size_digests = size_digests;
13247 device_param->size_shown = size_shown;
13248 device_param->size_salts = size_salts;
13249
13250 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13251 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13252 uint size_tm = 32 * sizeof (bs_word_t);
13253
13254 u64 size_scryptV = 1;
13255
13256 if ((hash_mode == 8900) || (hash_mode == 9300))
13257 {
13258 uint tmto_start = 0;
13259 uint tmto_stop = 10;
13260
13261 if (scrypt_tmto)
13262 {
13263 tmto_start = scrypt_tmto;
13264 }
13265 else
13266 {
13267 // in case the user did not specify the tmto manually
13268 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13269 // but set the lower end only in case the user has a device with too less memory
13270
13271 if (hash_mode == 8900)
13272 {
13273 if (device_param->vendor_id == VENDOR_ID_AMD)
13274 {
13275 tmto_start = 1;
13276 }
13277 else if (device_param->vendor_id == VENDOR_ID_NV)
13278 {
13279 tmto_start = 3;
13280 }
13281 }
13282 else if (hash_mode == 9300)
13283 {
13284 if (device_param->vendor_id == VENDOR_ID_AMD)
13285 {
13286 tmto_start = 3;
13287 }
13288 else if (device_param->vendor_id == VENDOR_ID_NV)
13289 {
13290 tmto_start = 5;
13291 }
13292 }
13293 }
13294
13295 if (quiet == 0) log_info ("");
13296
13297 uint shader_per_mp = 1;
13298
13299 if (device_param->vendor_id == VENDOR_ID_AMD)
13300 {
13301 shader_per_mp = 8;
13302 }
13303 else if (device_param->vendor_id == VENDOR_ID_NV)
13304 {
13305 shader_per_mp = 32;
13306 }
13307
13308 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13309 {
13310 // TODO: in theory the following calculation needs to be done per salt, not global
13311 // we assume all hashes have the same scrypt settings
13312
13313 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13314
13315 size_scryptV /= 1 << tmto;
13316
13317 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13318
13319 if (size_scryptV > device_param->device_maxmem_alloc)
13320 {
13321 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13322
13323 continue;
13324 }
13325
13326 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13327 {
13328 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13329 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13330 }
13331
13332 break;
13333 }
13334
13335 if (data.salts_buf[0].scrypt_phy == 0)
13336 {
13337 log_error ("ERROR: can't allocate enough device memory");
13338
13339 return -1;
13340 }
13341
13342 if (quiet == 0) log_info ("");
13343 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13344 }
13345
13346 /**
13347 * default building options
13348 */
13349
13350 char build_opts[1024];
13351
13352 // we don't have sm_* on vendors not NV but it doesn't matter
13353
13354 sprintf (build_opts, "-I%s/ -DVENDOR_ID=%d -DCUDA_ARCH=%d -DVECT_SIZE=%u", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width);
13355
13356 /**
13357 * main kernel
13358 */
13359
13360 {
13361 /**
13362 * kernel source filename
13363 */
13364
13365 char source_file[256] = { 0 };
13366
13367 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13368
13369 struct stat sst;
13370
13371 if (stat (source_file, &sst) == -1)
13372 {
13373 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13374
13375 return -1;
13376 }
13377
13378 /**
13379 * kernel cached filename
13380 */
13381
13382 char cached_file[256] = { 0 };
13383
13384 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13385
13386 int cached = 1;
13387
13388 struct stat cst;
13389
13390 if (stat (cached_file, &cst) == -1)
13391 {
13392 cached = 0;
13393 }
13394
13395 /**
13396 * kernel compile or load
13397 */
13398
13399 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13400
13401 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13402
13403 if (force_jit_compilation == -1)
13404 {
13405 if (cached == 0)
13406 {
13407 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13408
13409 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13410
13411 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13412
13413 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13414
13415 size_t binary_size;
13416
13417 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13418
13419 u8 *binary = (u8 *) mymalloc (binary_size);
13420
13421 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13422
13423 writeProgramBin (cached_file, binary, binary_size);
13424
13425 local_free (binary);
13426 }
13427 else
13428 {
13429 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13430
13431 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13432
13433 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13434
13435 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13436 }
13437 }
13438 else
13439 {
13440 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13441
13442 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13443
13444 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13445
13446 if (force_jit_compilation == 1500)
13447 {
13448 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13449 }
13450 else if (force_jit_compilation == 8900)
13451 {
13452 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);
13453 }
13454
13455 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13456 }
13457
13458 local_free (kernel_lengths);
13459 local_free (kernel_sources[0]);
13460 local_free (kernel_sources);
13461
13462 // this is mostly for debug
13463
13464 size_t ret_val_size = 0;
13465
13466 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13467
13468 if (ret_val_size > 2)
13469 {
13470 char *build_log = (char *) mymalloc (ret_val_size + 1);
13471
13472 memset (build_log, 0, ret_val_size + 1);
13473
13474 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13475
13476 puts (build_log);
13477
13478 myfree (build_log);
13479 }
13480 }
13481
13482 /**
13483 * word generator kernel
13484 */
13485
13486 if (attack_mode != ATTACK_MODE_STRAIGHT)
13487 {
13488 /**
13489 * kernel mp source filename
13490 */
13491
13492 char source_file[256] = { 0 };
13493
13494 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13495
13496 struct stat sst;
13497
13498 if (stat (source_file, &sst) == -1)
13499 {
13500 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13501
13502 return -1;
13503 }
13504
13505 /**
13506 * kernel mp cached filename
13507 */
13508
13509 char cached_file[256] = { 0 };
13510
13511 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13512
13513 int cached = 1;
13514
13515 struct stat cst;
13516
13517 if (stat (cached_file, &cst) == -1)
13518 {
13519 cached = 0;
13520 }
13521
13522 /**
13523 * kernel compile or load
13524 */
13525
13526 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13527
13528 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13529
13530 if (cached == 0)
13531 {
13532 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13533
13534 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13535
13536 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13537
13538 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13539
13540 size_t binary_size;
13541
13542 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13543
13544 u8 *binary = (u8 *) mymalloc (binary_size);
13545
13546 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13547
13548 writeProgramBin (cached_file, binary, binary_size);
13549
13550 local_free (binary);
13551 }
13552 else
13553 {
13554 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13555
13556 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13557
13558 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13559
13560 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13561 }
13562
13563 local_free (kernel_lengths);
13564 local_free (kernel_sources[0]);
13565 local_free (kernel_sources);
13566
13567 // this is mostly for debug
13568
13569 size_t ret_val_size = 0;
13570
13571 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13572
13573 if (ret_val_size > 2)
13574 {
13575 char *build_log = (char *) mymalloc (ret_val_size + 1);
13576
13577 memset (build_log, 0, ret_val_size + 1);
13578
13579 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13580
13581 puts (build_log);
13582
13583 myfree (build_log);
13584 }
13585 }
13586
13587 /**
13588 * amplifier kernel
13589 */
13590
13591 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13592 {
13593
13594 }
13595 else
13596 {
13597 /**
13598 * kernel amp source filename
13599 */
13600
13601 char source_file[256] = { 0 };
13602
13603 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13604
13605 struct stat sst;
13606
13607 if (stat (source_file, &sst) == -1)
13608 {
13609 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13610
13611 return -1;
13612 }
13613
13614 /**
13615 * kernel amp cached filename
13616 */
13617
13618 char cached_file[256] = { 0 };
13619
13620 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13621
13622 int cached = 1;
13623
13624 struct stat cst;
13625
13626 if (stat (cached_file, &cst) == -1)
13627 {
13628 cached = 0;
13629 }
13630
13631 /**
13632 * kernel compile or load
13633 */
13634
13635 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13636
13637 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13638
13639 if (cached == 0)
13640 {
13641 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13642
13643 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13644
13645 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13646
13647 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13648
13649 size_t binary_size;
13650
13651 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13652
13653 u8 *binary = (u8 *) mymalloc (binary_size);
13654
13655 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13656
13657 writeProgramBin (cached_file, binary, binary_size);
13658
13659 local_free (binary);
13660 }
13661 else
13662 {
13663 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13664
13665 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13666
13667 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13668
13669 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13670 }
13671
13672 local_free (kernel_lengths);
13673 local_free (kernel_sources[0]);
13674 local_free (kernel_sources);
13675
13676 // this is mostly for debug
13677
13678 size_t ret_val_size = 0;
13679
13680 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13681
13682 if (ret_val_size > 2)
13683 {
13684 char *build_log = (char *) mymalloc (ret_val_size + 1);
13685
13686 memset (build_log, 0, ret_val_size + 1);
13687
13688 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13689
13690 puts (build_log);
13691
13692 myfree (build_log);
13693 }
13694 }
13695
13696 /**
13697 * global buffers
13698 */
13699
13700 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13701 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13702 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13703 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13704 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13705 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13706 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13707 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13708 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13709 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13710 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13711 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13712 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13713 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13714 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13715 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13716 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13717 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13718
13719 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13720 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13721 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13722 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13723 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13724 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13725 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13726 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13727 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13728 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13729 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13730
13731 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13732 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13733 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13734 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13735 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13736 run_kernel_bzero (device_param, device_param->d_result, size_results);
13737
13738 /**
13739 * special buffers
13740 */
13741
13742 if (attack_kern == ATTACK_KERN_STRAIGHT)
13743 {
13744 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13745 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13746
13747 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13748
13749 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13750 }
13751 else if (attack_kern == ATTACK_KERN_COMBI)
13752 {
13753 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13754 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13755 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13756 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13757
13758 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13759 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13760 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13761 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13762 }
13763 else if (attack_kern == ATTACK_KERN_BF)
13764 {
13765 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13766 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13767 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13768 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13769 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13770
13771 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13772 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13773 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13774 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13775 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13776 }
13777
13778 if (size_esalts)
13779 {
13780 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13781
13782 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13783 }
13784
13785 /**
13786 * main host data
13787 */
13788
13789 uint *result = (uint *) mymalloc (size_results);
13790
13791 memset (result, 0, size_results);
13792
13793 device_param->result = result;
13794
13795 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13796
13797 memset (pws_buf, 0, size_pws);
13798
13799 device_param->pws_buf = pws_buf;
13800
13801 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13802
13803 for (int i = 0; i < 64; i++)
13804 {
13805 pw_caches[i].pw_buf.pw_len = i;
13806 pw_caches[i].cnt = 0;
13807 }
13808
13809 device_param->pw_caches = pw_caches;
13810
13811 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13812
13813 device_param->combs_buf = combs_buf;
13814
13815 void *hooks_buf = mymalloc (size_hooks);
13816
13817 device_param->hooks_buf = hooks_buf;
13818
13819 device_param->pw_transpose = pw_transpose_to_hi1;
13820 device_param->pw_add = pw_add_to_hc1;
13821
13822 /**
13823 * kernel args
13824 */
13825
13826 device_param->kernel_params_buf32[21] = bitmap_mask;
13827 device_param->kernel_params_buf32[22] = bitmap_shift1;
13828 device_param->kernel_params_buf32[23] = bitmap_shift2;
13829 device_param->kernel_params_buf32[24] = 0; // salt_pos
13830 device_param->kernel_params_buf32[25] = 0; // loop_pos
13831 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13832 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13833 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13834 device_param->kernel_params_buf32[29] = 0; // digests_offset
13835 device_param->kernel_params_buf32[30] = 0; // combs_mode
13836 device_param->kernel_params_buf32[31] = 0; // gid_max
13837
13838 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13839 ? &device_param->d_pws_buf
13840 : &device_param->d_pws_amp_buf;
13841 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13842 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13843 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13844 device_param->kernel_params[ 4] = &device_param->d_tmps;
13845 device_param->kernel_params[ 5] = &device_param->d_hooks;
13846 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13847 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13848 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13849 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13850 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13851 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13852 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13853 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13854 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13855 device_param->kernel_params[15] = &device_param->d_digests_buf;
13856 device_param->kernel_params[16] = &device_param->d_digests_shown;
13857 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13858 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13859 device_param->kernel_params[19] = &device_param->d_result;
13860 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13861 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13862 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13863 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13864 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13865 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13866 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13867 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13868 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13869 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13870 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13871 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13872
13873 device_param->kernel_params_mp_buf64[3] = 0;
13874 device_param->kernel_params_mp_buf32[4] = 0;
13875 device_param->kernel_params_mp_buf32[5] = 0;
13876 device_param->kernel_params_mp_buf32[6] = 0;
13877 device_param->kernel_params_mp_buf32[7] = 0;
13878 device_param->kernel_params_mp_buf32[8] = 0;
13879
13880 device_param->kernel_params_mp[0] = NULL;
13881 device_param->kernel_params_mp[1] = NULL;
13882 device_param->kernel_params_mp[2] = NULL;
13883 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13884 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13885 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13886 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13887 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13888 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13889
13890 device_param->kernel_params_mp_l_buf64[3] = 0;
13891 device_param->kernel_params_mp_l_buf32[4] = 0;
13892 device_param->kernel_params_mp_l_buf32[5] = 0;
13893 device_param->kernel_params_mp_l_buf32[6] = 0;
13894 device_param->kernel_params_mp_l_buf32[7] = 0;
13895 device_param->kernel_params_mp_l_buf32[8] = 0;
13896 device_param->kernel_params_mp_l_buf32[9] = 0;
13897
13898 device_param->kernel_params_mp_l[0] = NULL;
13899 device_param->kernel_params_mp_l[1] = NULL;
13900 device_param->kernel_params_mp_l[2] = NULL;
13901 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13902 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13903 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13904 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13905 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13906 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13907 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13908
13909 device_param->kernel_params_mp_r_buf64[3] = 0;
13910 device_param->kernel_params_mp_r_buf32[4] = 0;
13911 device_param->kernel_params_mp_r_buf32[5] = 0;
13912 device_param->kernel_params_mp_r_buf32[6] = 0;
13913 device_param->kernel_params_mp_r_buf32[7] = 0;
13914 device_param->kernel_params_mp_r_buf32[8] = 0;
13915
13916 device_param->kernel_params_mp_r[0] = NULL;
13917 device_param->kernel_params_mp_r[1] = NULL;
13918 device_param->kernel_params_mp_r[2] = NULL;
13919 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
13920 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
13921 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
13922 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
13923 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
13924 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
13925
13926 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
13927 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
13928
13929 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
13930 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
13931 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
13932 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
13933 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
13934 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
13935 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
13936
13937 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
13938
13939 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
13940 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
13941
13942 /**
13943 * kernel name
13944 */
13945
13946 char kernel_name[64] = { 0 };
13947
13948 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13949 {
13950 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13951 {
13952 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
13953
13954 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13955
13956 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
13957
13958 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13959
13960 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
13961
13962 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13963 }
13964 else
13965 {
13966 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
13967
13968 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13969
13970 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
13971
13972 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13973
13974 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
13975
13976 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13977 }
13978
13979 if (data.attack_mode == ATTACK_MODE_BF)
13980 {
13981 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13982 {
13983 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
13984
13985 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
13986
13987 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
13988
13989 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
13990 }
13991 }
13992 }
13993 else
13994 {
13995 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
13996
13997 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13998
13999 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14000
14001 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14002
14003 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14004
14005 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14006
14007 if (opts_type & OPTS_TYPE_HOOK12)
14008 {
14009 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14010
14011 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
14012 }
14013
14014 if (opts_type & OPTS_TYPE_HOOK23)
14015 {
14016 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14017
14018 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
14019 }
14020 }
14021
14022 for (uint i = 0; i <= 20; i++)
14023 {
14024 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14025 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14026 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14027
14028 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14029 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14030 }
14031
14032 for (uint i = 21; i <= 31; i++)
14033 {
14034 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14035 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14036 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14037
14038 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14039 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14040 }
14041
14042 if (attack_mode == ATTACK_MODE_BF)
14043 {
14044 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
14045 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
14046
14047 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14048 {
14049 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14050
14051 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14052 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14053 }
14054 }
14055 else if (attack_mode == ATTACK_MODE_HYBRID1)
14056 {
14057 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14058 }
14059 else if (attack_mode == ATTACK_MODE_HYBRID2)
14060 {
14061 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14062 }
14063
14064 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14065 {
14066 // nothing to do
14067 }
14068 else
14069 {
14070 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14071 }
14072
14073 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14074 {
14075 // nothing to do
14076 }
14077 else
14078 {
14079 for (uint i = 0; i < 5; i++)
14080 {
14081 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14082 }
14083
14084 for (uint i = 5; i < 7; i++)
14085 {
14086 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14087 }
14088 }
14089
14090 /**
14091 * Store initial fanspeed if gpu_temp_retain is enabled
14092 */
14093
14094 int gpu_temp_retain_set = 0;
14095
14096 if (gpu_temp_disable == 0)
14097 {
14098 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14099 {
14100 hc_thread_mutex_lock (mux_adl);
14101
14102 if (data.hm_device[device_id].fan_supported == 1)
14103 {
14104 if (gpu_temp_retain_chgd == 0)
14105 {
14106 uint cur_temp = 0;
14107 uint default_temp = 0;
14108
14109 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);
14110
14111 if (ADL_rc == ADL_OK)
14112 {
14113 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14114
14115 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14116
14117 // special case with multi gpu setups: always use minimum retain
14118
14119 if (gpu_temp_retain_set == 0)
14120 {
14121 gpu_temp_retain = gpu_temp_retain_target;
14122 gpu_temp_retain_set = 1;
14123 }
14124 else
14125 {
14126 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14127 }
14128
14129 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14130 }
14131 }
14132
14133 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14134
14135 temp_retain_fanspeed_value[device_id] = fan_speed;
14136
14137 if (fan_speed == -1)
14138 {
14139 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14140
14141 temp_retain_fanspeed_value[device_id] = 0;
14142 }
14143 }
14144
14145 hc_thread_mutex_unlock (mux_adl);
14146 }
14147 }
14148
14149 /**
14150 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14151 */
14152
14153 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14154 {
14155 hc_thread_mutex_lock (mux_adl);
14156
14157 if (data.hm_device[device_id].od_version == 6)
14158 {
14159 int ADL_rc;
14160
14161 // check powertune capabilities first, if not available then skip device
14162
14163 int powertune_supported = 0;
14164
14165 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14166 {
14167 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14168
14169 return (-1);
14170 }
14171
14172 if (powertune_supported != 0)
14173 {
14174 // powercontrol settings
14175
14176 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14177
14178 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14179 {
14180 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]);
14181 }
14182
14183 if (ADL_rc != ADL_OK)
14184 {
14185 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14186
14187 return (-1);
14188 }
14189
14190 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14191 {
14192 log_error ("ERROR: Failed to set new ADL PowerControl values");
14193
14194 return (-1);
14195 }
14196
14197 // clocks
14198
14199 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14200
14201 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14202
14203 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)
14204 {
14205 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14206
14207 return (-1);
14208 }
14209
14210 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14211
14212 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14213
14214 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14215 {
14216 log_error ("ERROR: Failed to get ADL device capabilities");
14217
14218 return (-1);
14219 }
14220
14221 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14222 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14223
14224 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14225 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14226
14227 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14228 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14229
14230 // warning if profile has to low max values
14231
14232 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14233 {
14234 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14235 }
14236
14237 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14238 {
14239 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14240 }
14241
14242 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14243
14244 performance_state->iNumberOfPerformanceLevels = 2;
14245
14246 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14247 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14248 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14249 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14250
14251 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)
14252 {
14253 log_info ("ERROR: Failed to set ADL performance state");
14254
14255 return (-1);
14256 }
14257
14258 local_free (performance_state);
14259 }
14260 }
14261
14262 hc_thread_mutex_unlock (mux_adl);
14263 }
14264 }
14265
14266 data.kernel_blocks_all = kernel_blocks_all;
14267
14268 if (data.quiet == 0) log_info ("");
14269
14270 /**
14271 * Inform user which algorithm is checked and at which workload setting
14272 */
14273
14274 if (benchmark == 1)
14275 {
14276 quiet = 0;
14277
14278 data.quiet = quiet;
14279
14280 char *hash_type = strhashtype (data.hash_mode); // not a bug
14281
14282 log_info ("Hashtype: %s", hash_type);
14283 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14284 log_info ("");
14285 }
14286
14287 /**
14288 * keep track of the progress
14289 */
14290
14291 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14292 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14293 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14294
14295 /**
14296 * open filehandles
14297 */
14298
14299 #if _WIN
14300 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14301 {
14302 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14303
14304 return (-1);
14305 }
14306
14307 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14308 {
14309 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14310
14311 return (-1);
14312 }
14313
14314 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14315 {
14316 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14317
14318 return (-1);
14319 }
14320 #endif
14321
14322 /**
14323 * dictionary pad
14324 */
14325
14326 segment_size *= (1024 * 1024);
14327
14328 data.segment_size = segment_size;
14329
14330 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14331
14332 wl_data->buf = (char *) mymalloc (segment_size);
14333 wl_data->avail = segment_size;
14334 wl_data->incr = segment_size;
14335 wl_data->cnt = 0;
14336 wl_data->pos = 0;
14337
14338 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14339
14340 data.wordlist_mode = wordlist_mode;
14341
14342 cs_t *css_buf = NULL;
14343 uint css_cnt = 0;
14344 uint dictcnt = 0;
14345 uint maskcnt = 1;
14346 char **masks = NULL;
14347 char **dictfiles = NULL;
14348
14349 uint mask_from_file = 0;
14350
14351 if (attack_mode == ATTACK_MODE_STRAIGHT)
14352 {
14353 if (wordlist_mode == WL_MODE_FILE)
14354 {
14355 int wls_left = myargc - (optind + 1);
14356
14357 for (int i = 0; i < wls_left; i++)
14358 {
14359 char *l0_filename = myargv[optind + 1 + i];
14360
14361 struct stat l0_stat;
14362
14363 if (stat (l0_filename, &l0_stat) == -1)
14364 {
14365 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14366
14367 return (-1);
14368 }
14369
14370 uint is_dir = S_ISDIR (l0_stat.st_mode);
14371
14372 if (is_dir == 0)
14373 {
14374 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14375
14376 dictcnt++;
14377
14378 dictfiles[dictcnt - 1] = l0_filename;
14379 }
14380 else
14381 {
14382 // do not allow --keyspace w/ a directory
14383
14384 if (keyspace == 1)
14385 {
14386 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14387
14388 return (-1);
14389 }
14390
14391 char **dictionary_files = NULL;
14392
14393 dictionary_files = scan_directory (l0_filename);
14394
14395 if (dictionary_files != NULL)
14396 {
14397 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14398
14399 for (int d = 0; dictionary_files[d] != NULL; d++)
14400 {
14401 char *l1_filename = dictionary_files[d];
14402
14403 struct stat l1_stat;
14404
14405 if (stat (l1_filename, &l1_stat) == -1)
14406 {
14407 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14408
14409 return (-1);
14410 }
14411
14412 if (S_ISREG (l1_stat.st_mode))
14413 {
14414 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14415
14416 dictcnt++;
14417
14418 dictfiles[dictcnt - 1] = strdup (l1_filename);
14419 }
14420 }
14421 }
14422
14423 local_free (dictionary_files);
14424 }
14425 }
14426
14427 if (dictcnt < 1)
14428 {
14429 log_error ("ERROR: No usable dictionary file found.");
14430
14431 return (-1);
14432 }
14433 }
14434 else if (wordlist_mode == WL_MODE_STDIN)
14435 {
14436 dictcnt = 1;
14437 }
14438 }
14439 else if (attack_mode == ATTACK_MODE_COMBI)
14440 {
14441 // display
14442
14443 char *dictfile1 = myargv[optind + 1 + 0];
14444 char *dictfile2 = myargv[optind + 1 + 1];
14445
14446 // find the bigger dictionary and use as base
14447
14448 FILE *fp1;
14449 FILE *fp2;
14450
14451 struct stat tmp_stat;
14452
14453 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14454 {
14455 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14456
14457 return (-1);
14458 }
14459
14460 if (stat (dictfile1, &tmp_stat) == -1)
14461 {
14462 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14463
14464 fclose (fp1);
14465
14466 return (-1);
14467 }
14468
14469 if (S_ISDIR (tmp_stat.st_mode))
14470 {
14471 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14472
14473 fclose (fp1);
14474
14475 return (-1);
14476 }
14477
14478 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14479 {
14480 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14481
14482 fclose (fp1);
14483
14484 return (-1);
14485 }
14486
14487 if (stat (dictfile2, &tmp_stat) == -1)
14488 {
14489 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14490
14491 fclose (fp1);
14492 fclose (fp2);
14493
14494 return (-1);
14495 }
14496
14497 if (S_ISDIR (tmp_stat.st_mode))
14498 {
14499 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14500
14501 fclose (fp1);
14502 fclose (fp2);
14503
14504 return (-1);
14505 }
14506
14507 data.combs_cnt = 1;
14508
14509 data.quiet = 1;
14510
14511 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14512
14513 data.quiet = quiet;
14514
14515 if (words1_cnt == 0)
14516 {
14517 log_error ("ERROR: %s: empty file", dictfile1);
14518
14519 fclose (fp1);
14520 fclose (fp2);
14521
14522 return (-1);
14523 }
14524
14525 data.combs_cnt = 1;
14526
14527 data.quiet = 1;
14528
14529 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14530
14531 data.quiet = quiet;
14532
14533 if (words2_cnt == 0)
14534 {
14535 log_error ("ERROR: %s: empty file", dictfile2);
14536
14537 fclose (fp1);
14538 fclose (fp2);
14539
14540 return (-1);
14541 }
14542
14543 fclose (fp1);
14544 fclose (fp2);
14545
14546 data.dictfile = dictfile1;
14547 data.dictfile2 = dictfile2;
14548
14549 if (words1_cnt >= words2_cnt)
14550 {
14551 data.combs_cnt = words2_cnt;
14552 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14553
14554 dictfiles = &data.dictfile;
14555
14556 dictcnt = 1;
14557 }
14558 else
14559 {
14560 data.combs_cnt = words1_cnt;
14561 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14562
14563 dictfiles = &data.dictfile2;
14564
14565 dictcnt = 1;
14566
14567 // we also have to switch wordlist related rules!
14568
14569 char *tmpc = data.rule_buf_l;
14570
14571 data.rule_buf_l = data.rule_buf_r;
14572 data.rule_buf_r = tmpc;
14573
14574 int tmpi = data.rule_len_l;
14575
14576 data.rule_len_l = data.rule_len_r;
14577 data.rule_len_r = tmpi;
14578 }
14579 }
14580 else if (attack_mode == ATTACK_MODE_BF)
14581 {
14582 char *mask = NULL;
14583
14584 maskcnt = 0;
14585
14586 if (benchmark == 0)
14587 {
14588 mask = myargv[optind + 1];
14589
14590 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14591
14592 if ((optind + 2) <= myargc)
14593 {
14594 struct stat file_stat;
14595
14596 if (stat (mask, &file_stat) == -1)
14597 {
14598 maskcnt = 1;
14599
14600 masks[maskcnt - 1] = mystrdup (mask);
14601 }
14602 else
14603 {
14604 int wls_left = myargc - (optind + 1);
14605
14606 uint masks_avail = INCR_MASKS;
14607
14608 for (int i = 0; i < wls_left; i++)
14609 {
14610 if (i != 0)
14611 {
14612 mask = myargv[optind + 1 + i];
14613
14614 if (stat (mask, &file_stat) == -1)
14615 {
14616 log_error ("ERROR: %s: %s", mask, strerror (errno));
14617
14618 return (-1);
14619 }
14620 }
14621
14622 uint is_file = S_ISREG (file_stat.st_mode);
14623
14624 if (is_file == 1)
14625 {
14626 FILE *mask_fp;
14627
14628 if ((mask_fp = fopen (mask, "r")) == NULL)
14629 {
14630 log_error ("ERROR: %s: %s", mask, strerror (errno));
14631
14632 return (-1);
14633 }
14634
14635 char line_buf[BUFSIZ];
14636
14637 while (!feof (mask_fp))
14638 {
14639 memset (line_buf, 0, BUFSIZ);
14640
14641 int line_len = fgetl (mask_fp, line_buf);
14642
14643 if (line_len == 0) continue;
14644
14645 if (line_buf[0] == '#') continue;
14646
14647 if (masks_avail == maskcnt)
14648 {
14649 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14650
14651 masks_avail += INCR_MASKS;
14652 }
14653
14654 masks[maskcnt] = mystrdup (line_buf);
14655
14656 maskcnt++;
14657 }
14658
14659 fclose (mask_fp);
14660 }
14661 else
14662 {
14663 log_error ("ERROR: %s: unsupported file-type", mask);
14664
14665 return (-1);
14666 }
14667 }
14668
14669 mask_from_file = 1;
14670 }
14671 }
14672 else
14673 {
14674 custom_charset_1 = (char *) "?l?d?u";
14675 custom_charset_2 = (char *) "?l?d";
14676 custom_charset_3 = (char *) "?l?d*!$@_";
14677
14678 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14679 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14680 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14681
14682 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14683
14684 wordlist_mode = WL_MODE_MASK;
14685
14686 data.wordlist_mode = wordlist_mode;
14687
14688 increment = 1;
14689
14690 maskcnt = 1;
14691 }
14692 }
14693 else
14694 {
14695 /**
14696 * generate full masks and charsets
14697 */
14698
14699 masks = (char **) mymalloc (sizeof (char *));
14700
14701 switch (hash_mode)
14702 {
14703 case 1731: pw_min = 5;
14704 pw_max = 5;
14705 mask = mystrdup ("?b?b?b?b?b");
14706 break;
14707 case 12500: pw_min = 5;
14708 pw_max = 5;
14709 mask = mystrdup ("?b?b?b?b?b");
14710 break;
14711 default: pw_min = 7;
14712 pw_max = 7;
14713 mask = mystrdup ("?b?b?b?b?b?b?b");
14714 break;
14715 }
14716
14717 maskcnt = 1;
14718
14719 masks[maskcnt - 1] = mystrdup (mask);
14720
14721 wordlist_mode = WL_MODE_MASK;
14722
14723 data.wordlist_mode = wordlist_mode;
14724
14725 increment = 1;
14726 }
14727
14728 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14729
14730 if (increment)
14731 {
14732 if (increment_min > pw_min) pw_min = increment_min;
14733
14734 if (increment_max < pw_max) pw_max = increment_max;
14735 }
14736 }
14737 else if (attack_mode == ATTACK_MODE_HYBRID1)
14738 {
14739 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14740
14741 // display
14742
14743 char *mask = myargv[myargc - 1];
14744
14745 maskcnt = 0;
14746
14747 masks = (char **) mymalloc (1 * sizeof (char *));
14748
14749 // mod
14750
14751 struct stat file_stat;
14752
14753 if (stat (mask, &file_stat) == -1)
14754 {
14755 maskcnt = 1;
14756
14757 masks[maskcnt - 1] = mystrdup (mask);
14758 }
14759 else
14760 {
14761 uint is_file = S_ISREG (file_stat.st_mode);
14762
14763 if (is_file == 1)
14764 {
14765 FILE *mask_fp;
14766
14767 if ((mask_fp = fopen (mask, "r")) == NULL)
14768 {
14769 log_error ("ERROR: %s: %s", mask, strerror (errno));
14770
14771 return (-1);
14772 }
14773
14774 char line_buf[BUFSIZ];
14775
14776 uint masks_avail = 1;
14777
14778 while (!feof (mask_fp))
14779 {
14780 memset (line_buf, 0, BUFSIZ);
14781
14782 int line_len = fgetl (mask_fp, line_buf);
14783
14784 if (line_len == 0) continue;
14785
14786 if (line_buf[0] == '#') continue;
14787
14788 if (masks_avail == maskcnt)
14789 {
14790 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14791
14792 masks_avail += INCR_MASKS;
14793 }
14794
14795 masks[maskcnt] = mystrdup (line_buf);
14796
14797 maskcnt++;
14798 }
14799
14800 fclose (mask_fp);
14801
14802 mask_from_file = 1;
14803 }
14804 else
14805 {
14806 maskcnt = 1;
14807
14808 masks[maskcnt - 1] = mystrdup (mask);
14809 }
14810 }
14811
14812 // base
14813
14814 int wls_left = myargc - (optind + 2);
14815
14816 for (int i = 0; i < wls_left; i++)
14817 {
14818 char *filename = myargv[optind + 1 + i];
14819
14820 struct stat file_stat;
14821
14822 if (stat (filename, &file_stat) == -1)
14823 {
14824 log_error ("ERROR: %s: %s", filename, strerror (errno));
14825
14826 return (-1);
14827 }
14828
14829 uint is_dir = S_ISDIR (file_stat.st_mode);
14830
14831 if (is_dir == 0)
14832 {
14833 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14834
14835 dictcnt++;
14836
14837 dictfiles[dictcnt - 1] = filename;
14838 }
14839 else
14840 {
14841 // do not allow --keyspace w/ a directory
14842
14843 if (keyspace == 1)
14844 {
14845 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14846
14847 return (-1);
14848 }
14849
14850 char **dictionary_files = NULL;
14851
14852 dictionary_files = scan_directory (filename);
14853
14854 if (dictionary_files != NULL)
14855 {
14856 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14857
14858 for (int d = 0; dictionary_files[d] != NULL; d++)
14859 {
14860 char *l1_filename = dictionary_files[d];
14861
14862 struct stat l1_stat;
14863
14864 if (stat (l1_filename, &l1_stat) == -1)
14865 {
14866 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14867
14868 return (-1);
14869 }
14870
14871 if (S_ISREG (l1_stat.st_mode))
14872 {
14873 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14874
14875 dictcnt++;
14876
14877 dictfiles[dictcnt - 1] = strdup (l1_filename);
14878 }
14879 }
14880 }
14881
14882 local_free (dictionary_files);
14883 }
14884 }
14885
14886 if (dictcnt < 1)
14887 {
14888 log_error ("ERROR: No usable dictionary file found.");
14889
14890 return (-1);
14891 }
14892
14893 if (increment)
14894 {
14895 maskcnt = 0;
14896
14897 uint mask_min = increment_min; // we can't reject smaller masks here
14898 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14899
14900 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14901 {
14902 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14903
14904 if (cur_mask == NULL) break;
14905
14906 masks[maskcnt] = cur_mask;
14907
14908 maskcnt++;
14909
14910 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14911 }
14912 }
14913 }
14914 else if (attack_mode == ATTACK_MODE_HYBRID2)
14915 {
14916 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14917
14918 // display
14919
14920 char *mask = myargv[optind + 1 + 0];
14921
14922 maskcnt = 0;
14923
14924 masks = (char **) mymalloc (1 * sizeof (char *));
14925
14926 // mod
14927
14928 struct stat file_stat;
14929
14930 if (stat (mask, &file_stat) == -1)
14931 {
14932 maskcnt = 1;
14933
14934 masks[maskcnt - 1] = mystrdup (mask);
14935 }
14936 else
14937 {
14938 uint is_file = S_ISREG (file_stat.st_mode);
14939
14940 if (is_file == 1)
14941 {
14942 FILE *mask_fp;
14943
14944 if ((mask_fp = fopen (mask, "r")) == NULL)
14945 {
14946 log_error ("ERROR: %s: %s", mask, strerror (errno));
14947
14948 return (-1);
14949 }
14950
14951 char line_buf[BUFSIZ];
14952
14953 uint masks_avail = 1;
14954
14955 while (!feof (mask_fp))
14956 {
14957 memset (line_buf, 0, BUFSIZ);
14958
14959 int line_len = fgetl (mask_fp, line_buf);
14960
14961 if (line_len == 0) continue;
14962
14963 if (line_buf[0] == '#') continue;
14964
14965 if (masks_avail == maskcnt)
14966 {
14967 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14968
14969 masks_avail += INCR_MASKS;
14970 }
14971
14972 masks[maskcnt] = mystrdup (line_buf);
14973
14974 maskcnt++;
14975 }
14976
14977 fclose (mask_fp);
14978
14979 mask_from_file = 1;
14980 }
14981 else
14982 {
14983 maskcnt = 1;
14984
14985 masks[maskcnt - 1] = mystrdup (mask);
14986 }
14987 }
14988
14989 // base
14990
14991 int wls_left = myargc - (optind + 2);
14992
14993 for (int i = 0; i < wls_left; i++)
14994 {
14995 char *filename = myargv[optind + 2 + i];
14996
14997 struct stat file_stat;
14998
14999 if (stat (filename, &file_stat) == -1)
15000 {
15001 log_error ("ERROR: %s: %s", filename, strerror (errno));
15002
15003 return (-1);
15004 }
15005
15006 uint is_dir = S_ISDIR (file_stat.st_mode);
15007
15008 if (is_dir == 0)
15009 {
15010 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15011
15012 dictcnt++;
15013
15014 dictfiles[dictcnt - 1] = filename;
15015 }
15016 else
15017 {
15018 // do not allow --keyspace w/ a directory
15019
15020 if (keyspace == 1)
15021 {
15022 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15023
15024 return (-1);
15025 }
15026
15027 char **dictionary_files = NULL;
15028
15029 dictionary_files = scan_directory (filename);
15030
15031 if (dictionary_files != NULL)
15032 {
15033 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15034
15035 for (int d = 0; dictionary_files[d] != NULL; d++)
15036 {
15037 char *l1_filename = dictionary_files[d];
15038
15039 struct stat l1_stat;
15040
15041 if (stat (l1_filename, &l1_stat) == -1)
15042 {
15043 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15044
15045 return (-1);
15046 }
15047
15048 if (S_ISREG (l1_stat.st_mode))
15049 {
15050 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15051
15052 dictcnt++;
15053
15054 dictfiles[dictcnt - 1] = strdup (l1_filename);
15055 }
15056 }
15057 }
15058
15059 local_free (dictionary_files);
15060 }
15061 }
15062
15063 if (dictcnt < 1)
15064 {
15065 log_error ("ERROR: No usable dictionary file found.");
15066
15067 return (-1);
15068 }
15069
15070 if (increment)
15071 {
15072 maskcnt = 0;
15073
15074 uint mask_min = increment_min; // we can't reject smaller masks here
15075 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15076
15077 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15078 {
15079 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15080
15081 if (cur_mask == NULL) break;
15082
15083 masks[maskcnt] = cur_mask;
15084
15085 maskcnt++;
15086
15087 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15088 }
15089 }
15090 }
15091
15092 data.pw_min = pw_min;
15093 data.pw_max = pw_max;
15094
15095 /**
15096 * weak hash check
15097 */
15098
15099 if (weak_hash_threshold >= salts_cnt)
15100 {
15101 uint first_device_id = 0;
15102
15103 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15104 {
15105 hc_device_param_t *device_param = &data.devices_param[device_id];
15106
15107 if (device_param->skipped) continue;
15108
15109 first_device_id = device_id;
15110
15111 break;
15112 }
15113
15114 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15115
15116 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15117 {
15118 weak_hash_check (&data.devices_param[first_device_id], salt_pos, kernel_loops);
15119 }
15120 }
15121
15122 // Display hack, guarantee that there is at least one \r before real start
15123
15124 if (data.quiet == 0) log_info_nn ("");
15125
15126 /**
15127 * status and monitor threads
15128 */
15129
15130 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15131
15132 hc_thread_t i_thread = 0;
15133
15134 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15135 {
15136 hc_thread_create (i_thread, thread_keypress, &benchmark);
15137 }
15138
15139 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15140
15141 uint ni_threads_cnt = 0;
15142
15143 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15144
15145 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15146
15147 ni_threads_cnt++;
15148
15149 /**
15150 * Outfile remove
15151 */
15152
15153 if (keyspace == 0)
15154 {
15155 if (outfile_check_timer != 0)
15156 {
15157 if (data.outfile_check_directory != NULL)
15158 {
15159 if ((hash_mode != 5200) &&
15160 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15161 (hash_mode != 9000))
15162 {
15163 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15164
15165 ni_threads_cnt++;
15166 }
15167 else
15168 {
15169 outfile_check_timer = 0;
15170 }
15171 }
15172 else
15173 {
15174 outfile_check_timer = 0;
15175 }
15176 }
15177 }
15178
15179 /**
15180 * Inform the user if we got some hashes remove because of the pot file remove feature
15181 */
15182
15183 if (data.quiet == 0)
15184 {
15185 if (potfile_remove_cracks > 0)
15186 {
15187 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15188 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15189 }
15190 }
15191
15192 data.outfile_check_timer = outfile_check_timer;
15193
15194 /**
15195 * main loop
15196 */
15197
15198 char **induction_dictionaries = NULL;
15199
15200 int induction_dictionaries_cnt = 0;
15201
15202 hcstat_table_t *root_table_buf = NULL;
15203 hcstat_table_t *markov_table_buf = NULL;
15204
15205 uint initial_restore_done = 0;
15206
15207 data.maskcnt = maskcnt;
15208
15209 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15210 {
15211 if (data.devices_status == STATUS_CRACKED) break;
15212
15213 data.devices_status = STATUS_INIT;
15214
15215 if (maskpos > rd->maskpos)
15216 {
15217 rd->dictpos = 0;
15218 }
15219
15220 rd->maskpos = maskpos;
15221 data.maskpos = maskpos;
15222
15223 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15224 {
15225 char *mask = masks[maskpos];
15226
15227 if (mask_from_file == 1)
15228 {
15229 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15230
15231 char *str_ptr;
15232 uint str_pos;
15233
15234 uint mask_offset = 0;
15235
15236 uint separator_cnt;
15237
15238 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15239 {
15240 str_ptr = strstr (mask + mask_offset, ",");
15241
15242 if (str_ptr == NULL) break;
15243
15244 str_pos = str_ptr - mask;
15245
15246 // escaped separator, i.e. "\,"
15247
15248 if (str_pos > 0)
15249 {
15250 if (mask[str_pos - 1] == '\\')
15251 {
15252 separator_cnt --;
15253
15254 mask_offset = str_pos + 1;
15255
15256 continue;
15257 }
15258 }
15259
15260 // reset the offset
15261
15262 mask_offset = 0;
15263
15264 mask[str_pos] = '\0';
15265
15266 switch (separator_cnt)
15267 {
15268 case 0:
15269 mp_reset_usr (mp_usr, 0);
15270
15271 custom_charset_1 = mask;
15272 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15273 break;
15274
15275 case 1:
15276 mp_reset_usr (mp_usr, 1);
15277
15278 custom_charset_2 = mask;
15279 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15280 break;
15281
15282 case 2:
15283 mp_reset_usr (mp_usr, 2);
15284
15285 custom_charset_3 = mask;
15286 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15287 break;
15288
15289 case 3:
15290 mp_reset_usr (mp_usr, 3);
15291
15292 custom_charset_4 = mask;
15293 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15294 break;
15295 }
15296
15297 mask = mask + str_pos + 1;
15298 }
15299 }
15300
15301 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15302 {
15303 if (maskpos > 0)
15304 {
15305 local_free (css_buf);
15306 local_free (data.root_css_buf);
15307 local_free (data.markov_css_buf);
15308
15309 local_free (masks[maskpos - 1]);
15310 }
15311
15312 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15313
15314 data.mask = mask;
15315 data.css_cnt = css_cnt;
15316 data.css_buf = css_buf;
15317
15318 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15319
15320 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15321
15322 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15323 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15324
15325 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15326
15327 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15328
15329 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15330 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15331
15332 data.root_css_buf = root_css_buf;
15333 data.markov_css_buf = markov_css_buf;
15334
15335 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15336
15337 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15338
15339 local_free (root_table_buf);
15340 local_free (markov_table_buf);
15341
15342 // args
15343
15344 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15345 {
15346 hc_device_param_t *device_param = &data.devices_param[device_id];
15347
15348 if (device_param->skipped) continue;
15349
15350 device_param->kernel_params_mp[0] = &device_param->d_combs;
15351 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15352 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15353
15354 device_param->kernel_params_mp_buf64[3] = 0;
15355 device_param->kernel_params_mp_buf32[4] = css_cnt;
15356 device_param->kernel_params_mp_buf32[5] = 0;
15357 device_param->kernel_params_mp_buf32[6] = 0;
15358 device_param->kernel_params_mp_buf32[7] = 0;
15359
15360 if (attack_mode == ATTACK_MODE_HYBRID1)
15361 {
15362 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15363 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15364 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15365 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15366 }
15367 else if (attack_mode == ATTACK_MODE_HYBRID2)
15368 {
15369 device_param->kernel_params_mp_buf32[5] = 0;
15370 device_param->kernel_params_mp_buf32[6] = 0;
15371 device_param->kernel_params_mp_buf32[7] = 0;
15372 }
15373
15374 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15375 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15376 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15377
15378 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);
15379 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);
15380 }
15381 }
15382 else if (attack_mode == ATTACK_MODE_BF)
15383 {
15384 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15385
15386 if (increment)
15387 {
15388 for (uint i = 0; i < dictcnt; i++)
15389 {
15390 local_free (dictfiles[i]);
15391 }
15392
15393 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15394 {
15395 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15396
15397 if (l1_filename == NULL) break;
15398
15399 dictcnt++;
15400
15401 dictfiles[dictcnt - 1] = l1_filename;
15402 }
15403 }
15404 else
15405 {
15406 dictcnt++;
15407
15408 dictfiles[dictcnt - 1] = mask;
15409 }
15410
15411 if (dictcnt == 0)
15412 {
15413 log_error ("ERROR: Mask is too small");
15414
15415 return (-1);
15416 }
15417 }
15418 }
15419
15420 free (induction_dictionaries);
15421
15422 // induction_dictionaries_cnt = 0; // implied
15423
15424 if (attack_mode != ATTACK_MODE_BF)
15425 {
15426 if (keyspace == 0)
15427 {
15428 induction_dictionaries = scan_directory (induction_directory);
15429
15430 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15431 }
15432 }
15433
15434 if (induction_dictionaries_cnt)
15435 {
15436 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15437 }
15438
15439 /**
15440 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15441 */
15442 if (keyspace == 1)
15443 {
15444 if ((maskcnt > 1) || (dictcnt > 1))
15445 {
15446 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15447
15448 return (-1);
15449 }
15450 }
15451
15452 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15453 {
15454 char *subid = logfile_generate_subid ();
15455
15456 data.subid = subid;
15457
15458 logfile_sub_msg ("START");
15459
15460 data.devices_status = STATUS_INIT;
15461
15462 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15463 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15464 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15465
15466 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15467
15468 data.cpt_pos = 0;
15469
15470 data.cpt_start = time (NULL);
15471
15472 data.cpt_total = 0;
15473
15474 if (data.restore == 0)
15475 {
15476 rd->words_cur = skip;
15477
15478 skip = 0;
15479
15480 data.skip = 0;
15481 }
15482
15483 data.ms_paused = 0;
15484
15485 data.words_cur = rd->words_cur;
15486
15487 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15488 {
15489 hc_device_param_t *device_param = &data.devices_param[device_id];
15490
15491 if (device_param->skipped) continue;
15492
15493 device_param->speed_pos = 0;
15494
15495 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15496 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15497 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15498
15499 device_param->kernel_power = device_param->kernel_power_user;
15500 device_param->kernel_blocks = device_param->kernel_blocks_user;
15501
15502 device_param->outerloop_pos = 0;
15503 device_param->outerloop_left = 0;
15504 device_param->innerloop_pos = 0;
15505 device_param->innerloop_left = 0;
15506
15507 // some more resets:
15508
15509 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15510
15511 memset (device_param->pws_buf, 0, device_param->size_pws);
15512
15513 device_param->pw_cnt = 0;
15514 device_param->pws_cnt = 0;
15515
15516 device_param->words_off = 0;
15517 device_param->words_done = 0;
15518 }
15519
15520 data.kernel_blocks_div = 0;
15521
15522 // figure out some workload
15523
15524 if (attack_mode == ATTACK_MODE_STRAIGHT)
15525 {
15526 if (data.wordlist_mode == WL_MODE_FILE)
15527 {
15528 char *dictfile = NULL;
15529
15530 if (induction_dictionaries_cnt)
15531 {
15532 dictfile = induction_dictionaries[0];
15533 }
15534 else
15535 {
15536 dictfile = dictfiles[dictpos];
15537 }
15538
15539 data.dictfile = dictfile;
15540
15541 logfile_sub_string (dictfile);
15542
15543 for (uint i = 0; i < rp_files_cnt; i++)
15544 {
15545 logfile_sub_var_string ("rulefile", rp_files[i]);
15546 }
15547
15548 FILE *fd2 = fopen (dictfile, "rb");
15549
15550 if (fd2 == NULL)
15551 {
15552 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15553
15554 return (-1);
15555 }
15556
15557 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15558
15559 fclose (fd2);
15560
15561 if (data.words_cnt == 0)
15562 {
15563 if (data.devices_status == STATUS_CRACKED) break;
15564 if (data.devices_status == STATUS_ABORTED) break;
15565
15566 dictpos++;
15567
15568 continue;
15569 }
15570 }
15571 }
15572 else if (attack_mode == ATTACK_MODE_COMBI)
15573 {
15574 char *dictfile = data.dictfile;
15575 char *dictfile2 = data.dictfile2;
15576
15577 logfile_sub_string (dictfile);
15578 logfile_sub_string (dictfile2);
15579
15580 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15581 {
15582 FILE *fd2 = fopen (dictfile, "rb");
15583
15584 if (fd2 == NULL)
15585 {
15586 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15587
15588 return (-1);
15589 }
15590
15591 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15592
15593 fclose (fd2);
15594 }
15595 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15596 {
15597 FILE *fd2 = fopen (dictfile2, "rb");
15598
15599 if (fd2 == NULL)
15600 {
15601 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15602
15603 return (-1);
15604 }
15605
15606 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15607
15608 fclose (fd2);
15609 }
15610
15611 if (data.words_cnt == 0)
15612 {
15613 if (data.devices_status == STATUS_CRACKED) break;
15614 if (data.devices_status == STATUS_ABORTED) break;
15615
15616 dictpos++;
15617
15618 continue;
15619 }
15620 }
15621 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15622 {
15623 char *dictfile = NULL;
15624
15625 if (induction_dictionaries_cnt)
15626 {
15627 dictfile = induction_dictionaries[0];
15628 }
15629 else
15630 {
15631 dictfile = dictfiles[dictpos];
15632 }
15633
15634 data.dictfile = dictfile;
15635
15636 char *mask = data.mask;
15637
15638 logfile_sub_string (dictfile);
15639 logfile_sub_string (mask);
15640
15641 FILE *fd2 = fopen (dictfile, "rb");
15642
15643 if (fd2 == NULL)
15644 {
15645 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15646
15647 return (-1);
15648 }
15649
15650 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15651
15652 fclose (fd2);
15653
15654 if (data.words_cnt == 0)
15655 {
15656 if (data.devices_status == STATUS_CRACKED) break;
15657 if (data.devices_status == STATUS_ABORTED) break;
15658
15659 dictpos++;
15660
15661 continue;
15662 }
15663 }
15664 else if (attack_mode == ATTACK_MODE_BF)
15665 {
15666 local_free (css_buf);
15667 local_free (data.root_css_buf);
15668 local_free (data.markov_css_buf);
15669
15670 char *mask = dictfiles[dictpos];
15671
15672 logfile_sub_string (mask);
15673
15674 // base
15675
15676 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15677
15678 if (opts_type & OPTS_TYPE_PT_UNICODE)
15679 {
15680 uint css_cnt_unicode = css_cnt * 2;
15681
15682 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15683
15684 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15685 {
15686 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15687
15688 css_buf_unicode[j + 1].cs_buf[0] = 0;
15689 css_buf_unicode[j + 1].cs_len = 1;
15690 }
15691
15692 free (css_buf);
15693
15694 css_buf = css_buf_unicode;
15695 css_cnt = css_cnt_unicode;
15696 }
15697
15698 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15699
15700 uint mask_min = pw_min;
15701 uint mask_max = pw_max;
15702
15703 if (opts_type & OPTS_TYPE_PT_UNICODE)
15704 {
15705 mask_min *= 2;
15706 mask_max *= 2;
15707 }
15708
15709 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15710 {
15711 if (css_cnt < mask_min)
15712 {
15713 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15714 }
15715
15716 if (css_cnt > mask_max)
15717 {
15718 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15719 }
15720
15721 // skip to next mask
15722
15723 dictpos++;
15724
15725 rd->dictpos = dictpos;
15726
15727 logfile_sub_msg ("STOP");
15728
15729 continue;
15730 }
15731
15732 uint save_css_cnt = css_cnt;
15733
15734 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15735 {
15736 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15737 {
15738 uint salt_len = (uint) data.salts_buf[0].salt_len;
15739 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15740
15741 uint css_cnt_salt = css_cnt + salt_len;
15742
15743 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15744
15745 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15746
15747 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15748 {
15749 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15750 css_buf_salt[j].cs_len = 1;
15751 }
15752
15753 free (css_buf);
15754
15755 css_buf = css_buf_salt;
15756 css_cnt = css_cnt_salt;
15757 }
15758 }
15759
15760 data.mask = mask;
15761 data.css_cnt = css_cnt;
15762 data.css_buf = css_buf;
15763
15764 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15765
15766 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15767
15768 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15769
15770 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15771 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15772
15773 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15774
15775 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15776
15777 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15778 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15779
15780 data.root_css_buf = root_css_buf;
15781 data.markov_css_buf = markov_css_buf;
15782
15783 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15784
15785 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15786
15787 local_free (root_table_buf);
15788 local_free (markov_table_buf);
15789
15790 // copy + args
15791
15792 uint css_cnt_l = css_cnt;
15793 uint css_cnt_r;
15794
15795 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15796 {
15797 if (save_css_cnt < 6)
15798 {
15799 css_cnt_r = 1;
15800 }
15801 else if (save_css_cnt == 6)
15802 {
15803 css_cnt_r = 2;
15804 }
15805 else
15806 {
15807 if (opts_type & OPTS_TYPE_PT_UNICODE)
15808 {
15809 if (save_css_cnt == 8 || save_css_cnt == 10)
15810 {
15811 css_cnt_r = 2;
15812 }
15813 else
15814 {
15815 css_cnt_r = 4;
15816 }
15817 }
15818 else
15819 {
15820 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15821 {
15822 css_cnt_r = 3;
15823 }
15824 else
15825 {
15826 css_cnt_r = 4;
15827 }
15828 }
15829 }
15830 }
15831 else
15832 {
15833 css_cnt_r = 1;
15834
15835 /* unfinished code?
15836 int sum = css_buf[css_cnt_r - 1].cs_len;
15837
15838 for (uint i = 1; i < 4 && i < css_cnt; i++)
15839 {
15840 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15841
15842 css_cnt_r++;
15843
15844 sum *= css_buf[css_cnt_r - 1].cs_len;
15845 }
15846 */
15847 }
15848
15849 css_cnt_l -= css_cnt_r;
15850
15851 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15852
15853 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15854 {
15855 hc_device_param_t *device_param = &data.devices_param[device_id];
15856
15857 if (device_param->skipped) continue;
15858
15859 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15860 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15861 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15862
15863 device_param->kernel_params_mp_l_buf64[3] = 0;
15864 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15865 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15866 device_param->kernel_params_mp_l_buf32[6] = 0;
15867 device_param->kernel_params_mp_l_buf32[7] = 0;
15868 device_param->kernel_params_mp_l_buf32[8] = 0;
15869
15870 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15871 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15872 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15873 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15874
15875 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15876 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15877 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15878
15879 device_param->kernel_params_mp_r_buf64[3] = 0;
15880 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15881 device_param->kernel_params_mp_r_buf32[5] = 0;
15882 device_param->kernel_params_mp_r_buf32[6] = 0;
15883 device_param->kernel_params_mp_r_buf32[7] = 0;
15884
15885 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]);
15886 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]);
15887 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]);
15888
15889 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]);
15890 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]);
15891 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]);
15892
15893 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);
15894 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);
15895 }
15896 }
15897
15898 u64 words_base = data.words_cnt;
15899
15900 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15901 {
15902 if (data.kernel_rules_cnt)
15903 {
15904 words_base /= data.kernel_rules_cnt;
15905 }
15906 }
15907 else if (data.attack_kern == ATTACK_KERN_COMBI)
15908 {
15909 if (data.combs_cnt)
15910 {
15911 words_base /= data.combs_cnt;
15912 }
15913 }
15914 else if (data.attack_kern == ATTACK_KERN_BF)
15915 {
15916 if (data.bfs_cnt)
15917 {
15918 words_base /= data.bfs_cnt;
15919 }
15920 }
15921
15922 data.words_base = words_base;
15923
15924 if (keyspace == 1)
15925 {
15926 log_info ("%llu", (unsigned long long int) words_base);
15927
15928 return (0);
15929 }
15930
15931 if (data.words_cur > data.words_base)
15932 {
15933 log_error ("ERROR: restore value greater keyspace");
15934
15935 return (-1);
15936 }
15937
15938 if (data.words_cur)
15939 {
15940 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15941 {
15942 for (uint i = 0; i < data.salts_cnt; i++)
15943 {
15944 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
15945 }
15946 }
15947 else if (data.attack_kern == ATTACK_KERN_COMBI)
15948 {
15949 for (uint i = 0; i < data.salts_cnt; i++)
15950 {
15951 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
15952 }
15953 }
15954 else if (data.attack_kern == ATTACK_KERN_BF)
15955 {
15956 for (uint i = 0; i < data.salts_cnt; i++)
15957 {
15958 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
15959 }
15960 }
15961 }
15962
15963 /*
15964 * Inform user about possible slow speeds
15965 */
15966
15967 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15968 {
15969 if (data.words_base < kernel_blocks_all)
15970 {
15971 if (quiet == 0)
15972 {
15973 log_info ("");
15974 log_info ("ATTENTION!");
15975 log_info (" The wordlist or mask you are using is too small.");
15976 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
15977 log_info (" The cracking speed will drop.");
15978 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
15979 log_info ("");
15980 }
15981 }
15982 }
15983
15984 /*
15985 * Update loopback file
15986 */
15987
15988 if (loopback == 1)
15989 {
15990 time_t now;
15991
15992 time (&now);
15993
15994 uint random_num = get_random_num (0, 9999);
15995
15996 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
15997
15998 data.loopback_file = loopback_file;
15999 }
16000
16001 /*
16002 * Update dictionary statistic
16003 */
16004
16005 if (keyspace == 0)
16006 {
16007 dictstat_fp = fopen (dictstat, "wb");
16008
16009 if (dictstat_fp)
16010 {
16011 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16012
16013 fclose (dictstat_fp);
16014 }
16015 }
16016
16017 data.devices_status = STATUS_RUNNING;
16018
16019 if (initial_restore_done == 0)
16020 {
16021 if (data.restore_disable == 0) cycle_restore ();
16022
16023 initial_restore_done = 1;
16024 }
16025
16026 hc_timer_set (&data.timer_running);
16027
16028 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16029 {
16030 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16031 {
16032 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16033 if (quiet == 0) fflush (stdout);
16034 }
16035 }
16036 else if (wordlist_mode == WL_MODE_STDIN)
16037 {
16038 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16039 if (data.quiet == 0) log_info ("");
16040 }
16041
16042 time_t runtime_start;
16043
16044 time (&runtime_start);
16045
16046 data.runtime_start = runtime_start;
16047
16048 /**
16049 * create cracker threads
16050 */
16051
16052 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16053
16054 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16055 {
16056 hc_device_param_t *device_param = &devices_param[device_id];
16057
16058 if (wordlist_mode == WL_MODE_STDIN)
16059 {
16060 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16061 }
16062 else
16063 {
16064 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16065 }
16066 }
16067
16068 // wait for crack threads to exit
16069
16070 hc_thread_wait (devices_cnt, c_threads);
16071
16072 local_free (c_threads);
16073
16074 data.restore = 0;
16075
16076 // finalize task
16077
16078 logfile_sub_var_uint ("status-after-work", data.devices_status);
16079
16080 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16081
16082 if (data.devices_status == STATUS_CRACKED) break;
16083 if (data.devices_status == STATUS_ABORTED) break;
16084
16085 if (data.devices_status == STATUS_BYPASS)
16086 {
16087 data.devices_status = STATUS_RUNNING;
16088 }
16089
16090 if (induction_dictionaries_cnt)
16091 {
16092 unlink (induction_dictionaries[0]);
16093 }
16094
16095 free (induction_dictionaries);
16096
16097 if (attack_mode != ATTACK_MODE_BF)
16098 {
16099 induction_dictionaries = scan_directory (induction_directory);
16100
16101 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16102 }
16103
16104 if (benchmark == 0)
16105 {
16106 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16107 {
16108 if (quiet == 0) clear_prompt ();
16109
16110 if (quiet == 0) log_info ("");
16111
16112 if (status == 1)
16113 {
16114 status_display ();
16115 }
16116 else
16117 {
16118 if (quiet == 0) status_display ();
16119 }
16120
16121 if (quiet == 0) log_info ("");
16122 }
16123 }
16124
16125 if (attack_mode == ATTACK_MODE_BF)
16126 {
16127 dictpos++;
16128
16129 rd->dictpos = dictpos;
16130 }
16131 else
16132 {
16133 if (induction_dictionaries_cnt)
16134 {
16135 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16136 }
16137 else
16138 {
16139 dictpos++;
16140
16141 rd->dictpos = dictpos;
16142 }
16143 }
16144
16145 time_t runtime_stop;
16146
16147 time (&runtime_stop);
16148
16149 data.runtime_stop = runtime_stop;
16150
16151 logfile_sub_uint (runtime_start);
16152 logfile_sub_uint (runtime_stop);
16153
16154 logfile_sub_msg ("STOP");
16155
16156 global_free (subid);
16157 }
16158
16159 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16160
16161 if (data.devices_status == STATUS_CRACKED) break;
16162 if (data.devices_status == STATUS_ABORTED) break;
16163 if (data.devices_status == STATUS_QUIT) break;
16164
16165 if (data.devices_status == STATUS_BYPASS)
16166 {
16167 data.devices_status = STATUS_RUNNING;
16168 }
16169 }
16170
16171 // 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
16172
16173 if (attack_mode == ATTACK_MODE_STRAIGHT)
16174 {
16175 if (data.wordlist_mode == WL_MODE_FILE)
16176 {
16177 if (data.dictfile == NULL)
16178 {
16179 if (dictfiles != NULL)
16180 {
16181 data.dictfile = dictfiles[0];
16182
16183 hc_timer_set (&data.timer_running);
16184 }
16185 }
16186 }
16187 }
16188 // NOTE: combi is okay because it is already set beforehand
16189 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16190 {
16191 if (data.dictfile == NULL)
16192 {
16193 if (dictfiles != NULL)
16194 {
16195 hc_timer_set (&data.timer_running);
16196
16197 data.dictfile = dictfiles[0];
16198 }
16199 }
16200 }
16201 else if (attack_mode == ATTACK_MODE_BF)
16202 {
16203 if (data.mask == NULL)
16204 {
16205 hc_timer_set (&data.timer_running);
16206
16207 data.mask = masks[0];
16208 }
16209 }
16210
16211 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16212 {
16213 data.devices_status = STATUS_EXHAUSTED;
16214 }
16215
16216 // if cracked / aborted remove last induction dictionary
16217
16218 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16219 {
16220 struct stat induct_stat;
16221
16222 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16223 {
16224 unlink (induction_dictionaries[file_pos]);
16225 }
16226 }
16227
16228 // wait for non-interactive threads
16229
16230 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16231 {
16232 hc_thread_wait (1, &ni_threads[thread_idx]);
16233 }
16234
16235 local_free (ni_threads);
16236
16237 // wait for interactive threads
16238
16239 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16240 {
16241 hc_thread_wait (1, &i_thread);
16242 }
16243
16244 // we dont need restore file anymore
16245 if (data.restore_disable == 0)
16246 {
16247 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16248 {
16249 unlink (eff_restore_file);
16250 unlink (new_restore_file);
16251 }
16252 else
16253 {
16254 cycle_restore ();
16255 }
16256 }
16257
16258 // finally save left hashes
16259
16260 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16261 {
16262 save_hash ();
16263 }
16264
16265 /**
16266 * Clean up
16267 */
16268
16269 if (benchmark == 1)
16270 {
16271 status_benchmark ();
16272
16273 log_info ("");
16274 }
16275 else
16276 {
16277 if (quiet == 0) clear_prompt ();
16278
16279 if (quiet == 0) log_info ("");
16280
16281 if (status == 1)
16282 {
16283 status_display ();
16284 }
16285 else
16286 {
16287 if (quiet == 0) status_display ();
16288 }
16289
16290 if (quiet == 0) log_info ("");
16291 }
16292
16293 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16294 {
16295 hc_device_param_t *device_param = &data.devices_param[device_id];
16296
16297 if (device_param->skipped) continue;
16298
16299 local_free (device_param->result);
16300
16301 local_free (device_param->pw_caches);
16302
16303 local_free (device_param->combs_buf);
16304
16305 local_free (device_param->hooks_buf);
16306
16307 local_free (device_param->device_name);
16308
16309 local_free (device_param->device_name_chksum);
16310
16311 local_free (device_param->device_version);
16312
16313 local_free (device_param->driver_version);
16314
16315 if (device_param->pws_buf) myfree (device_param->pws_buf);
16316 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16317 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16318 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16319 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16320 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16321 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16322 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16323 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16324 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16325 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16326 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16327 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16328 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16329 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16330 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16331 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16332 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16333 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16334 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16335 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16336 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16337 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16338 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16339 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16340 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16341 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16342 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16343 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16344
16345 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16346 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16347 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16348 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16349 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16350 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16351 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16352 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16353 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16354 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16355 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16356
16357 if (device_param->program) hc_clReleaseProgram (device_param->program);
16358 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16359 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16360
16361 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16362 if (device_param->context) hc_clReleaseContext (device_param->context);
16363 }
16364
16365 // reset default fan speed
16366
16367 if (gpu_temp_disable == 0)
16368 {
16369 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16370 {
16371 hc_thread_mutex_lock (mux_adl);
16372
16373 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16374 {
16375 hc_device_param_t *device_param = &data.devices_param[device_id];
16376
16377 if (device_param->skipped) continue;
16378
16379 if (data.hm_device[device_id].fan_supported == 1)
16380 {
16381 int fanspeed = temp_retain_fanspeed_value[device_id];
16382
16383 if (fanspeed == -1) continue;
16384
16385 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16386
16387 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16388 }
16389 }
16390
16391 hc_thread_mutex_unlock (mux_adl);
16392 }
16393 }
16394
16395 // reset power tuning
16396
16397 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16398 {
16399 hc_thread_mutex_lock (mux_adl);
16400
16401 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16402 {
16403 hc_device_param_t *device_param = &data.devices_param[device_id];
16404
16405 if (device_param->skipped) continue;
16406
16407 if (data.hm_device[device_id].od_version == 6)
16408 {
16409 // check powertune capabilities first, if not available then skip device
16410
16411 int powertune_supported = 0;
16412
16413 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16414 {
16415 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16416
16417 return (-1);
16418 }
16419
16420 if (powertune_supported != 0)
16421 {
16422 // powercontrol settings
16423
16424 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, od_power_control_status[device_id])) != ADL_OK)
16425 {
16426 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16427
16428 return (-1);
16429 }
16430
16431 // clocks
16432
16433 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16434
16435 performance_state->iNumberOfPerformanceLevels = 2;
16436
16437 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16438 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16439 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16440 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16441
16442 if ((hc_ADL_Overdrive_State_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16443 {
16444 log_info ("ERROR: Failed to restore ADL performance state");
16445
16446 return (-1);
16447 }
16448
16449 local_free (performance_state);
16450 }
16451 }
16452 }
16453
16454 hc_thread_mutex_unlock (mux_adl);
16455 }
16456
16457 if (gpu_temp_disable == 0)
16458 {
16459 #ifdef LINUX
16460 if (data.hm_dll_nv)
16461 {
16462 hc_NVML_nvmlShutdown (data.hm_dll_nv);
16463
16464 hm_close (data.hm_dll_nv);
16465 }
16466 #endif
16467
16468 #ifdef WIN
16469 NvAPI_Unload ();
16470 #endif
16471
16472 if (data.hm_dll_amd)
16473 {
16474 hc_ADL_Main_Control_Destroy (data.hm_dll_amd);
16475
16476 hm_close (data.hm_dll_amd);
16477 }
16478 }
16479
16480 // free memory
16481
16482 local_free (masks);
16483
16484 local_free (dictstat_base);
16485
16486 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16487 {
16488 pot_t *pot_ptr = &pot[pot_pos];
16489
16490 hash_t *hash = &pot_ptr->hash;
16491
16492 local_free (hash->digest);
16493
16494 if (isSalted)
16495 {
16496 local_free (hash->salt);
16497 }
16498 }
16499
16500 local_free (pot);
16501
16502 local_free (all_kernel_rules_cnt);
16503 local_free (all_kernel_rules_buf);
16504
16505 local_free (wl_data->buf);
16506 local_free (wl_data);
16507
16508 local_free (bitmap_s1_a);
16509 local_free (bitmap_s1_b);
16510 local_free (bitmap_s1_c);
16511 local_free (bitmap_s1_d);
16512 local_free (bitmap_s2_a);
16513 local_free (bitmap_s2_b);
16514 local_free (bitmap_s2_c);
16515 local_free (bitmap_s2_d);
16516
16517 local_free (temp_retain_fanspeed_value);
16518 local_free (od_clock_mem_status);
16519 local_free (od_power_control_status);
16520
16521 global_free (devices_param);
16522
16523 global_free (kernel_rules_buf);
16524
16525 global_free (root_css_buf);
16526 global_free (markov_css_buf);
16527
16528 global_free (digests_buf);
16529 global_free (digests_shown);
16530 global_free (digests_shown_tmp);
16531
16532 global_free (salts_buf);
16533 global_free (salts_shown);
16534
16535 global_free (esalts_buf);
16536
16537 global_free (words_progress_done);
16538 global_free (words_progress_rejected);
16539 global_free (words_progress_restored);
16540
16541 if (pot_fp) fclose (pot_fp);
16542
16543 if (data.devices_status == STATUS_QUIT) break;
16544 }
16545
16546 // destroy others mutex
16547
16548 hc_thread_mutex_delete (mux_dispatcher);
16549 hc_thread_mutex_delete (mux_counter);
16550 hc_thread_mutex_delete (mux_display);
16551 hc_thread_mutex_delete (mux_adl);
16552
16553 // free memory
16554
16555 local_free (eff_restore_file);
16556 local_free (new_restore_file);
16557
16558 local_free (rd);
16559
16560 // loopback
16561
16562 local_free (loopback_file);
16563
16564 if (loopback == 1) unlink (loopback_file);
16565
16566 // induction directory
16567
16568 if (induction_dir == NULL)
16569 {
16570 if (attack_mode != ATTACK_MODE_BF)
16571 {
16572 if (rmdir (induction_directory) == -1)
16573 {
16574 if (errno == ENOENT)
16575 {
16576 // good, we can ignore
16577 }
16578 else if (errno == ENOTEMPTY)
16579 {
16580 // good, we can ignore
16581 }
16582 else
16583 {
16584 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16585
16586 return (-1);
16587 }
16588 }
16589
16590 local_free (induction_directory);
16591 }
16592 }
16593
16594 // outfile-check directory
16595
16596 if (outfile_check_dir == NULL)
16597 {
16598 if (rmdir (outfile_check_directory) == -1)
16599 {
16600 if (errno == ENOENT)
16601 {
16602 // good, we can ignore
16603 }
16604 else if (errno == ENOTEMPTY)
16605 {
16606 // good, we can ignore
16607 }
16608 else
16609 {
16610 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16611
16612 return (-1);
16613 }
16614 }
16615
16616 local_free (outfile_check_directory);
16617 }
16618
16619 time_t proc_stop;
16620
16621 time (&proc_stop);
16622
16623 logfile_top_uint (proc_start);
16624 logfile_top_uint (proc_stop);
16625
16626 logfile_top_msg ("STOP");
16627
16628 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16629 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16630
16631 if (data.devices_status == STATUS_ABORTED) return 2;
16632 if (data.devices_status == STATUS_QUIT) return 2;
16633 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16634 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16635 if (data.devices_status == STATUS_CRACKED) return 0;
16636
16637 return -1;
16638 }
Hashcat additions to support pwdhash