projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Prepare NEW_SIMD_MODE for -a 1 kernels
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define BENCHMARK_REPEATS 2
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMT_HASHCAT 0
101 #define HLFMT_PWDUMP 1
102 #define HLFMT_PASSWD 2
103 #define HLFMT_SHADOW 3
104 #define HLFMT_DCC 4
105 #define HLFMT_DCC2 5
106 #define HLFMT_NETNTLM1 7
107 #define HLFMT_NETNTLM2 8
108 #define HLFMT_NSLDAP 9
109 #define HLFMT_NSLDAPS 10
110 #define HLFMTS_CNT 11
111
112 #define ATTACK_MODE_STRAIGHT 0
113 #define ATTACK_MODE_COMBI 1
114 #define ATTACK_MODE_TOGGLE 2
115 #define ATTACK_MODE_BF 3
116 #define ATTACK_MODE_PERM 4
117 #define ATTACK_MODE_TABLE 5
118 #define ATTACK_MODE_HYBRID1 6
119 #define ATTACK_MODE_HYBRID2 7
120 #define ATTACK_MODE_NONE 100
121
122 #define ATTACK_KERN_STRAIGHT 0
123 #define ATTACK_KERN_COMBI 1
124 #define ATTACK_KERN_BF 3
125 #define ATTACK_KERN_NONE 100
126
127 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
128 #define ATTACK_EXEC_INSIDE_KERNEL 11
129
130 #define COMBINATOR_MODE_BASE_LEFT 10001
131 #define COMBINATOR_MODE_BASE_RIGHT 10002
132
133 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
134 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
135
136 #define MAX_CUT_TRIES 4
137
138 #define MAX_DICTSTAT 10000
139
140 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 131
141
142 #define global_free(attr) \
143 { \
144 myfree ((void *) data.attr); \
145 \
146 data.attr = NULL; \
147 }
148
149 #define local_free(attr) \
150 { \
151 myfree ((void *) attr); \
152 \
153 attr = NULL; \
154 }
155
156 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
157 {
158 900,
159 0,
160 5100,
161 100,
162 1400,
163 10800,
164 1700,
165 5000,
166 10100,
167 6000,
168 6100,
169 6900,
170 11700,
171 11800,
172 400,
173 8900,
174 11900,
175 12000,
176 10900,
177 12100,
178 23,
179 2500,
180 5300,
181 5400,
182 5500,
183 5600,
184 7300,
185 7500,
186 13100,
187 8300,
188 11100,
189 11200,
190 11400,
191 121,
192 2611,
193 2711,
194 2811,
195 8400,
196 11,
197 2612,
198 7900,
199 21,
200 11000,
201 124,
202 10000,
203 3711,
204 7600,
205 12,
206 131,
207 132,
208 1731,
209 200,
210 300,
211 3100,
212 112,
213 12300,
214 8000,
215 141,
216 1441,
217 1600,
218 12600,
219 1421,
220 101,
221 111,
222 1711,
223 3000,
224 1000,
225 1100,
226 2100,
227 12800,
228 1500,
229 12400,
230 500,
231 3200,
232 7400,
233 1800,
234 122,
235 1722,
236 7100,
237 6300,
238 6700,
239 6400,
240 6500,
241 2400,
242 2410,
243 5700,
244 9200,
245 9300,
246 22,
247 501,
248 5800,
249 8100,
250 8500,
251 7200,
252 9900,
253 7700,
254 7800,
255 10300,
256 8600,
257 8700,
258 9100,
259 133,
260 11600,
261 12500,
262 13000,
263 6211,
264 6221,
265 6231,
266 6241,
267 8800,
268 12900,
269 12200,
270 9700,
271 9710,
272 9800,
273 9810,
274 9400,
275 9500,
276 9600,
277 10400,
278 10410,
279 10500,
280 10600,
281 10700,
282 9000,
283 5200,
284 6800,
285 6600,
286 8200,
287 11300,
288 12700
289 };
290
291 /**
292 * types
293 */
294
295 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
296
297 /**
298 * globals
299 */
300
301 static unsigned int full01 = 0x01010101;
302 static unsigned int full80 = 0x80808080;
303
304 int SUPPRESS_OUTPUT = 0;
305
306 hc_thread_mutex_t mux_adl;
307 hc_thread_mutex_t mux_counter;
308 hc_thread_mutex_t mux_dispatcher;
309 hc_thread_mutex_t mux_display;
310
311 hc_global_data_t data;
312
313 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
314
315 const char *USAGE_MINI[] =
316 {
317 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
318 "",
319 "Try --help for more help.",
320 NULL
321 };
322
323 const char *USAGE_BIG[] =
324 {
325 "%s, advanced password recovery",
326 "",
327 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
328 "",
329 "=======",
330 "Options",
331 "=======",
332 "",
333 "* General:",
334 "",
335 " -m, --hash-type=NUM Hash-type, see references below",
336 " -a, --attack-mode=NUM Attack-mode, see references below",
337 " -V, --version Print version",
338 " -h, --help Print help",
339 " --quiet Suppress output",
340 "",
341 "* Misc:",
342 "",
343 " --hex-charset Assume charset is given in hex",
344 " --hex-salt Assume salt is given in hex",
345 " --hex-wordlist Assume words in wordlist is given in hex",
346 " --force Ignore warnings",
347 " --status Enable automatic update of the status-screen",
348 " --status-timer=NUM Seconds between status-screen update",
349 " --status-automat Display the status view in a machine readable format",
350 " --loopback Add new plains to induct directory",
351 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
352 "",
353 "* Markov:",
354 "",
355 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
356 " --markov-disable Disables markov-chains, emulates classic brute-force",
357 " --markov-classic Enables classic markov-chains, no per-position enhancement",
358 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
359 "",
360 "* Session:",
361 "",
362 " --runtime=NUM Abort session after NUM seconds of runtime",
363 " --session=STR Define specific session name",
364 " --restore Restore session from --session",
365 " --restore-disable Do not write restore file",
366 "",
367 "* Files:",
368 "",
369 " -o, --outfile=FILE Define outfile for recovered hash",
370 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
371 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
372 " --outfile-check-timer=NUM Seconds between outfile checks",
373 " -p, --separator=CHAR Separator char for hashlists and outfile",
374 " --show Show cracked passwords only",
375 " --left Show un-cracked passwords only",
376 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
377 " --remove Enable remove of hash once it is cracked",
378 " --remove-timer=NUM Update input hash file each NUM seconds",
379 " --potfile-disable Do not write potfile",
380 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
381 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
382 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
383 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
384 " --logfile-disable Disable the logfile",
385 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
386 "",
387 "* Resources:",
388 "",
389 " -b, --benchmark Run benchmark",
390 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
391 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
392 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
393 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
394 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
395 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
396 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
397 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
398 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
399 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
400 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
401 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
402 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
403 #ifdef HAVE_HWMON
404 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
405 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
406 #ifdef HAVE_ADL
407 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
408 #endif
409 #endif
410 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
411 "",
412 "* Distributed:",
413 "",
414 " -s, --skip=NUM Skip number of words",
415 " -l, --limit=NUM Limit number of words",
416 " --keyspace Show keyspace base:mod values and quit",
417 "",
418 "* Rules:",
419 "",
420 " -j, --rule-left=RULE Single rule applied to each word from left dict",
421 " -k, --rule-right=RULE Single rule applied to each word from right dict",
422 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
423 " -g, --generate-rules=NUM Generate NUM random rules",
424 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
425 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
426 " --generate-rules-seed=NUM Force RNG seed to NUM",
427 "",
428 "* Custom charsets:",
429 "",
430 " -1, --custom-charset1=CS User-defined charsets",
431 " -2, --custom-charset2=CS Example:",
432 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
433 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
434 "",
435 "* Increment:",
436 "",
437 " -i, --increment Enable increment mode",
438 " --increment-min=NUM Start incrementing at NUM",
439 " --increment-max=NUM Stop incrementing at NUM",
440 "",
441 "==========",
442 "References",
443 "==========",
444 "",
445 "* Workload Profile:",
446 "",
447 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
448 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
449 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
450 "",
451 "* OpenCL device-types:",
452 "",
453 " 1 = CPU devices",
454 " 2 = GPU devices",
455 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
456 "",
457 "* Outfile Formats:",
458 "",
459 " 1 = hash[:salt]",
460 " 2 = plain",
461 " 3 = hash[:salt]:plain",
462 " 4 = hex_plain",
463 " 5 = hash[:salt]:hex_plain",
464 " 6 = plain:hex_plain",
465 " 7 = hash[:salt]:plain:hex_plain",
466 " 8 = crackpos",
467 " 9 = hash[:salt]:crackpos",
468 " 10 = plain:crackpos",
469 " 11 = hash[:salt]:plain:crackpos",
470 " 12 = hex_plain:crackpos",
471 " 13 = hash[:salt]:hex_plain:crackpos",
472 " 14 = plain:hex_plain:crackpos",
473 " 15 = hash[:salt]:plain:hex_plain:crackpos",
474 "",
475 "* Debug mode output formats (for hybrid mode only, by using rules):",
476 "",
477 " 1 = save finding rule",
478 " 2 = save original word",
479 " 3 = save original word and finding rule",
480 " 4 = save original word, finding rule and modified plain",
481 "",
482 "* Built-in charsets:",
483 "",
484 " ?l = abcdefghijklmnopqrstuvwxyz",
485 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
486 " ?d = 0123456789",
487 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
488 " ?a = ?l?u?d?s",
489 " ?b = 0x00 - 0xff",
490 "",
491 "* Attack modes:",
492 "",
493 " 0 = Straight",
494 " 1 = Combination",
495 " 3 = Brute-force",
496 " 6 = Hybrid dict + mask",
497 " 7 = Hybrid mask + dict",
498 "",
499 "* Hash types:",
500 "",
501 "[[ Roll-your-own: Raw Hashes ]]",
502 "",
503 " 900 = MD4",
504 " 0 = MD5",
505 " 5100 = Half MD5",
506 " 100 = SHA1",
507 " 10800 = SHA-384",
508 " 1400 = SHA-256",
509 " 1700 = SHA-512",
510 " 5000 = SHA-3(Keccak)",
511 " 10100 = SipHash",
512 " 6000 = RipeMD160",
513 " 6100 = Whirlpool",
514 " 6900 = GOST R 34.11-94",
515 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
516 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
517 "",
518 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
519 "",
520 " 10 = md5($pass.$salt)",
521 " 20 = md5($salt.$pass)",
522 " 30 = md5(unicode($pass).$salt)",
523 " 40 = md5($salt.unicode($pass))",
524 " 3800 = md5($salt.$pass.$salt)",
525 " 3710 = md5($salt.md5($pass))",
526 " 2600 = md5(md5($pass)",
527 " 4300 = md5(strtoupper(md5($pass)))",
528 " 4400 = md5(sha1($pass))",
529 " 110 = sha1($pass.$salt)",
530 " 120 = sha1($salt.$pass)",
531 " 130 = sha1(unicode($pass).$salt)",
532 " 140 = sha1($salt.unicode($pass))",
533 " 4500 = sha1(sha1($pass)",
534 " 4700 = sha1(md5($pass))",
535 " 4900 = sha1($salt.$pass.$salt)",
536 " 1410 = sha256($pass.$salt)",
537 " 1420 = sha256($salt.$pass)",
538 " 1430 = sha256(unicode($pass).$salt)",
539 " 1440 = sha256($salt.unicode($pass))",
540 " 1710 = sha512($pass.$salt)",
541 " 1720 = sha512($salt.$pass)",
542 " 1730 = sha512(unicode($pass).$salt)",
543 " 1740 = sha512($salt.unicode($pass))",
544 "",
545 "[[ Roll-your-own: Authenticated Hashes ]]",
546 "",
547 " 50 = HMAC-MD5 (key = $pass)",
548 " 60 = HMAC-MD5 (key = $salt)",
549 " 150 = HMAC-SHA1 (key = $pass)",
550 " 160 = HMAC-SHA1 (key = $salt)",
551 " 1450 = HMAC-SHA256 (key = $pass)",
552 " 1460 = HMAC-SHA256 (key = $salt)",
553 " 1750 = HMAC-SHA512 (key = $pass)",
554 " 1760 = HMAC-SHA512 (key = $salt)",
555 "",
556 "[[ Generic KDF ]]",
557 "",
558 " 400 = phpass",
559 " 8900 = scrypt",
560 " 11900 = PBKDF2-HMAC-MD5",
561 " 12000 = PBKDF2-HMAC-SHA1",
562 " 10900 = PBKDF2-HMAC-SHA256",
563 " 12100 = PBKDF2-HMAC-SHA512",
564 "",
565 "[[ Network protocols, Challenge-Response ]]",
566 "",
567 " 23 = Skype",
568 " 2500 = WPA/WPA2",
569 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
570 " 5300 = IKE-PSK MD5",
571 " 5400 = IKE-PSK SHA1",
572 " 5500 = NetNTLMv1",
573 " 5500 = NetNTLMv1 + ESS",
574 " 5600 = NetNTLMv2",
575 " 7300 = IPMI2 RAKP HMAC-SHA1",
576 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
577 " 8300 = DNSSEC (NSEC3)",
578 " 10200 = Cram MD5",
579 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
580 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
581 " 11400 = SIP digest authentication (MD5)",
582 " 13100 = Kerberos 5 TGS-REP etype 23",
583 "",
584 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
585 "",
586 " 121 = SMF (Simple Machines Forum)",
587 " 400 = phpBB3",
588 " 2611 = vBulletin < v3.8.5",
589 " 2711 = vBulletin > v3.8.5",
590 " 2811 = MyBB",
591 " 2811 = IPB (Invison Power Board)",
592 " 8400 = WBB3 (Woltlab Burning Board)",
593 " 11 = Joomla < 2.5.18",
594 " 400 = Joomla > 2.5.18",
595 " 400 = Wordpress",
596 " 2612 = PHPS",
597 " 7900 = Drupal7",
598 " 21 = osCommerce",
599 " 21 = xt:Commerce",
600 " 11000 = PrestaShop",
601 " 124 = Django (SHA-1)",
602 " 10000 = Django (PBKDF2-SHA256)",
603 " 3711 = Mediawiki B type",
604 " 7600 = Redmine",
605 "",
606 "[[ Database Server ]]",
607 "",
608 " 12 = PostgreSQL",
609 " 131 = MSSQL(2000)",
610 " 132 = MSSQL(2005)",
611 " 1731 = MSSQL(2012)",
612 " 1731 = MSSQL(2014)",
613 " 200 = MySQL323",
614 " 300 = MySQL4.1/MySQL5",
615 " 3100 = Oracle H: Type (Oracle 7+)",
616 " 112 = Oracle S: Type (Oracle 11+)",
617 " 12300 = Oracle T: Type (Oracle 12+)",
618 " 8000 = Sybase ASE",
619 "",
620 "[[ HTTP, SMTP, LDAP Server ]]",
621 "",
622 " 141 = EPiServer 6.x < v4",
623 " 1441 = EPiServer 6.x > v4",
624 " 1600 = Apache $apr1$",
625 " 12600 = ColdFusion 10+",
626 " 1421 = hMailServer",
627 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
628 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
629 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
630 "",
631 "[[ Checksums ]]",
632 "",
633 " 11500 = CRC32",
634 "",
635 "[[ Operating-Systems ]]",
636 "",
637 " 3000 = LM",
638 " 1000 = NTLM",
639 " 1100 = Domain Cached Credentials (DCC), MS Cache",
640 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
641 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
642 " 1500 = descrypt, DES(Unix), Traditional DES",
643 " 12400 = BSDiCrypt, Extended DES",
644 " 500 = md5crypt $1$, MD5(Unix)",
645 " 3200 = bcrypt $2*$, Blowfish(Unix)",
646 " 7400 = sha256crypt $5$, SHA256(Unix)",
647 " 1800 = sha512crypt $6$, SHA512(Unix)",
648 " 122 = OSX v10.4",
649 " 122 = OSX v10.5",
650 " 122 = OSX v10.6",
651 " 1722 = OSX v10.7",
652 " 7100 = OSX v10.8",
653 " 7100 = OSX v10.9",
654 " 7100 = OSX v10.10",
655 " 6300 = AIX {smd5}",
656 " 6700 = AIX {ssha1}",
657 " 6400 = AIX {ssha256}",
658 " 6500 = AIX {ssha512}",
659 " 2400 = Cisco-PIX",
660 " 2410 = Cisco-ASA",
661 " 500 = Cisco-IOS $1$",
662 " 5700 = Cisco-IOS $4$",
663 " 9200 = Cisco-IOS $8$",
664 " 9300 = Cisco-IOS $9$",
665 " 22 = Juniper Netscreen/SSG (ScreenOS)",
666 " 501 = Juniper IVE",
667 " 5800 = Android PIN",
668 " 8100 = Citrix Netscaler",
669 " 8500 = RACF",
670 " 7200 = GRUB 2",
671 " 9900 = Radmin2",
672 "",
673 "[[ Enterprise Application Software (EAS) ]]",
674 "",
675 " 7700 = SAP CODVN B (BCODE)",
676 " 7800 = SAP CODVN F/G (PASSCODE)",
677 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
678 " 8600 = Lotus Notes/Domino 5",
679 " 8700 = Lotus Notes/Domino 6",
680 " 9100 = Lotus Notes/Domino 8",
681 " 133 = PeopleSoft",
682 "",
683 "[[ Archives ]]",
684 "",
685 " 11600 = 7-Zip",
686 " 12500 = RAR3-hp",
687 " 13000 = RAR5",
688 "",
689 "[[ Full-Disk encryptions (FDE) ]]",
690 "",
691 " 62XY = TrueCrypt 5.0+",
692 " X = 1 = PBKDF2-HMAC-RipeMD160",
693 " X = 2 = PBKDF2-HMAC-SHA512",
694 " X = 3 = PBKDF2-HMAC-Whirlpool",
695 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
696 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
697 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
698 " Y = 3 = XTS 1536 bit (Ciphers: All)",
699 " 8800 = Android FDE < v4.3",
700 " 12900 = Android FDE (Samsung DEK)",
701 " 12200 = eCryptfs",
702 "",
703 "[[ Documents ]]",
704 "",
705 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
706 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
707 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
708 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
709 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
710 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
711 " 9400 = MS Office 2007",
712 " 9500 = MS Office 2010",
713 " 9600 = MS Office 2013",
714 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
715 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
716 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
717 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
718 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
719 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
720 "",
721 "[[ Password Managers ]]",
722 "",
723 " 9000 = Password Safe v2",
724 " 5200 = Password Safe v3",
725 " 6800 = Lastpass",
726 " 6600 = 1Password, agilekeychain",
727 " 8200 = 1Password, cloudkeychain",
728 " 11300 = Bitcoin/Litecoin wallet.dat",
729 " 12700 = Blockchain, My Wallet",
730 "",
731 NULL
732 };
733
734 /**
735 * oclHashcat specific functions
736 */
737
738 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
739 {
740 int exec_pos = (int) device_param->exec_pos - last_num_entries;
741
742 if (exec_pos < 0) exec_pos += EXEC_CACHE;
743
744 double exec_ms_sum = 0;
745
746 int exec_ms_cnt = 0;
747
748 for (int i = 0; i < last_num_entries; i++)
749 {
750 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
751
752 if (exec_ms)
753 {
754 exec_ms_sum += exec_ms;
755
756 exec_ms_cnt++;
757 }
758 }
759
760 if (exec_ms_cnt == 0) return 0;
761
762 return exec_ms_sum / exec_ms_cnt;
763 }
764
765 void status_display_automat ()
766 {
767 FILE *out = stdout;
768
769 fprintf (out, "STATUS\t%u\t", data.devices_status);
770
771 /**
772 * speed new
773 */
774
775 fprintf (out, "SPEED\t");
776
777 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
778 {
779 hc_device_param_t *device_param = &data.devices_param[device_id];
780
781 if (device_param->skipped) continue;
782
783 u64 speed_cnt = 0;
784 float speed_ms = 0;
785
786 for (int i = 0; i < SPEED_CACHE; i++)
787 {
788 float rec_ms;
789
790 hc_timer_get (device_param->speed_rec[i], rec_ms);
791
792 if (rec_ms > SPEED_MAXAGE) continue;
793
794 speed_cnt += device_param->speed_cnt[i];
795 speed_ms += device_param->speed_ms[i];
796 }
797
798 speed_cnt /= SPEED_CACHE;
799 speed_ms /= SPEED_CACHE;
800
801 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
802 }
803
804 /**
805 * exec time
806 */
807
808 fprintf (out, "EXEC_RUNTIME\t");
809
810 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
811 {
812 hc_device_param_t *device_param = &data.devices_param[device_id];
813
814 if (device_param->skipped) continue;
815
816 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
817
818 fprintf (out, "%f\t", exec_ms_avg);
819 }
820
821 /**
822 * words_cur
823 */
824
825 u64 words_cur = get_lowest_words_done ();
826
827 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
828
829 /**
830 * counter
831 */
832
833 uint salts_left = data.salts_cnt - data.salts_done;
834
835 if (salts_left == 0) salts_left = 1;
836
837 u64 progress_total = data.words_cnt * salts_left;
838
839 u64 all_done = 0;
840 u64 all_rejected = 0;
841 u64 all_restored = 0;
842
843 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
844 {
845 if (salts_left > 1)
846 {
847 // otherwise the final cracked status shows 0/XXX progress
848
849 if (data.salts_shown[salt_pos] == 1) continue;
850 }
851
852 all_done += data.words_progress_done[salt_pos];
853 all_rejected += data.words_progress_rejected[salt_pos];
854 all_restored += data.words_progress_restored[salt_pos];
855 }
856
857 u64 progress_cur = all_restored + all_done + all_rejected;
858 u64 progress_end = progress_total;
859
860 u64 progress_skip = 0;
861
862 if (data.skip)
863 {
864 progress_skip = MIN (data.skip, data.words_base) * salts_left;
865
866 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
867 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
868 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
869 }
870
871 if (data.limit)
872 {
873 progress_end = MIN (data.limit, data.words_base) * salts_left;
874
875 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
876 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
877 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
878 }
879
880 u64 progress_cur_relative_skip = progress_cur - progress_skip;
881 u64 progress_end_relative_skip = progress_end - progress_skip;
882
883 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
884
885 /**
886 * cracks
887 */
888
889 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
890 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
891
892 /**
893 * temperature
894 */
895
896 #ifdef HAVE_HWMON
897 if (data.gpu_temp_disable == 0)
898 {
899 fprintf (out, "TEMP\t");
900
901 hc_thread_mutex_lock (mux_adl);
902
903 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
904 {
905 hc_device_param_t *device_param = &data.devices_param[device_id];
906
907 if (device_param->skipped) continue;
908
909 int temp = hm_get_temperature_with_device_id (device_id);
910
911 fprintf (out, "%d\t", temp);
912 }
913
914 hc_thread_mutex_unlock (mux_adl);
915 }
916 #endif // HAVE_HWMON
917
918 /**
919 * flush
920 */
921
922 #ifdef _WIN
923 fputc ('\r', out);
924 fputc ('\n', out);
925 #endif
926
927 #ifdef _POSIX
928 fputc ('\n', out);
929 #endif
930
931 fflush (out);
932 }
933
934 void status_display ()
935 {
936 if (data.devices_status == STATUS_INIT) return;
937 if (data.devices_status == STATUS_STARTING) return;
938 if (data.devices_status == STATUS_BYPASS) return;
939
940 if (data.status_automat == 1)
941 {
942 status_display_automat ();
943
944 return;
945 }
946
947 char tmp_buf[1000] = { 0 };
948
949 uint tmp_len = 0;
950
951 log_info ("Session.Name...: %s", data.session);
952
953 char *status_type = strstatus (data.devices_status);
954
955 uint hash_mode = data.hash_mode;
956
957 char *hash_type = strhashtype (hash_mode); // not a bug
958
959 log_info ("Status.........: %s", status_type);
960
961 /**
962 * show rules
963 */
964
965 if (data.rp_files_cnt)
966 {
967 uint i;
968
969 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
970 {
971 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
972 }
973
974 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
975
976 log_info ("Rules.Type.....: %s", tmp_buf);
977
978 tmp_len = 0;
979 }
980
981 if (data.rp_gen)
982 {
983 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
984
985 if (data.rp_gen_seed)
986 {
987 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
988 }
989 }
990
991 /**
992 * show input
993 */
994
995 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
996 {
997 if (data.wordlist_mode == WL_MODE_FILE)
998 {
999 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1000 }
1001 else if (data.wordlist_mode == WL_MODE_STDIN)
1002 {
1003 log_info ("Input.Mode.....: Pipe");
1004 }
1005 }
1006 else if (data.attack_mode == ATTACK_MODE_COMBI)
1007 {
1008 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1009 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1010 }
1011 else if (data.attack_mode == ATTACK_MODE_BF)
1012 {
1013 char *mask = data.mask;
1014
1015 if (mask != NULL)
1016 {
1017 uint mask_len = data.css_cnt;
1018
1019 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1020
1021 if (mask_len > 0)
1022 {
1023 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1024 {
1025 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1026 {
1027 mask_len -= data.salts_buf[0].salt_len;
1028 }
1029 }
1030
1031 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1032
1033 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1034 }
1035
1036 if (data.maskcnt > 1)
1037 {
1038 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1039
1040 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1041 }
1042
1043 log_info ("Input.Mode.....: %s", tmp_buf);
1044 }
1045
1046 tmp_len = 0;
1047 }
1048 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1049 {
1050 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1051 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1052 }
1053 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1054 {
1055 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1056 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1057 }
1058
1059 if (data.digests_cnt == 1)
1060 {
1061 if (data.hash_mode == 2500)
1062 {
1063 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1064
1065 uint pke[25] = { 0 };
1066
1067 char *pke_ptr = (char *) pke;
1068
1069 for (uint i = 0; i < 25; i++)
1070 {
1071 pke[i] = byte_swap_32 (wpa->pke[i]);
1072 }
1073
1074 char mac1[6] = { 0 };
1075 char mac2[6] = { 0 };
1076
1077 memcpy (mac1, pke_ptr + 23, 6);
1078 memcpy (mac2, pke_ptr + 29, 6);
1079
1080 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1081 (char *) data.salts_buf[0].salt_buf,
1082 mac1[0] & 0xff,
1083 mac1[1] & 0xff,
1084 mac1[2] & 0xff,
1085 mac1[3] & 0xff,
1086 mac1[4] & 0xff,
1087 mac1[5] & 0xff,
1088 mac2[0] & 0xff,
1089 mac2[1] & 0xff,
1090 mac2[2] & 0xff,
1091 mac2[3] & 0xff,
1092 mac2[4] & 0xff,
1093 mac2[5] & 0xff);
1094 }
1095 else if (data.hash_mode == 5200)
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else if (data.hash_mode == 9000)
1100 {
1101 log_info ("Hash.Target....: File (%s)", data.hashfile);
1102 }
1103 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 else
1108 {
1109 char out_buf[4096] = { 0 };
1110
1111 ascii_digest (out_buf, 0, 0);
1112
1113 // limit length
1114 if (strlen (out_buf) > 40)
1115 {
1116 out_buf[41] = '.';
1117 out_buf[42] = '.';
1118 out_buf[43] = '.';
1119 out_buf[44] = 0;
1120 }
1121
1122 log_info ("Hash.Target....: %s", out_buf);
1123 }
1124 }
1125 else
1126 {
1127 if (data.hash_mode == 3000)
1128 {
1129 char out_buf1[4096] = { 0 };
1130 char out_buf2[4096] = { 0 };
1131
1132 ascii_digest (out_buf1, 0, 0);
1133 ascii_digest (out_buf2, 0, 1);
1134
1135 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1136 }
1137 else
1138 {
1139 log_info ("Hash.Target....: File (%s)", data.hashfile);
1140 }
1141 }
1142
1143 log_info ("Hash.Type......: %s", hash_type);
1144
1145 /**
1146 * speed new
1147 */
1148
1149 u64 speed_cnt[DEVICES_MAX] = { 0 };
1150 float speed_ms[DEVICES_MAX] = { 0 };
1151
1152 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1153 {
1154 hc_device_param_t *device_param = &data.devices_param[device_id];
1155
1156 if (device_param->skipped) continue;
1157
1158 // we need to clear values (set to 0) because in case the device does
1159 // not get new candidates it idles around but speed display would
1160 // show it as working.
1161 // if we instantly set it to 0 after reading it happens that the
1162 // speed can be shown as zero if the users refreshes too fast.
1163 // therefore, we add a timestamp when a stat was recorded and if its
1164 // too old we will not use it
1165
1166 speed_cnt[device_id] = 0;
1167 speed_ms[device_id] = 0;
1168
1169 for (int i = 0; i < SPEED_CACHE; i++)
1170 {
1171 float rec_ms;
1172
1173 hc_timer_get (device_param->speed_rec[i], rec_ms);
1174
1175 if (rec_ms > SPEED_MAXAGE) continue;
1176
1177 speed_cnt[device_id] += device_param->speed_cnt[i];
1178 speed_ms[device_id] += device_param->speed_ms[i];
1179 }
1180
1181 speed_cnt[device_id] /= SPEED_CACHE;
1182 speed_ms[device_id] /= SPEED_CACHE;
1183 }
1184
1185 float hashes_all_ms = 0;
1186
1187 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1188
1189 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1190 {
1191 hc_device_param_t *device_param = &data.devices_param[device_id];
1192
1193 if (device_param->skipped) continue;
1194
1195 hashes_dev_ms[device_id] = 0;
1196
1197 if (speed_ms[device_id])
1198 {
1199 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1200
1201 hashes_all_ms += hashes_dev_ms[device_id];
1202 }
1203 }
1204
1205 /**
1206 * exec time
1207 */
1208
1209 double exec_all_ms[DEVICES_MAX] = { 0 };
1210
1211 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1212 {
1213 hc_device_param_t *device_param = &data.devices_param[device_id];
1214
1215 if (device_param->skipped) continue;
1216
1217 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1218
1219 exec_all_ms[device_id] = exec_ms_avg;
1220 }
1221
1222 /**
1223 * timers
1224 */
1225
1226 float ms_running = 0;
1227
1228 hc_timer_get (data.timer_running, ms_running);
1229
1230 float ms_paused = data.ms_paused;
1231
1232 if (data.devices_status == STATUS_PAUSED)
1233 {
1234 float ms_paused_tmp = 0;
1235
1236 hc_timer_get (data.timer_paused, ms_paused_tmp);
1237
1238 ms_paused += ms_paused_tmp;
1239 }
1240
1241 #ifdef WIN
1242
1243 __time64_t sec_run = ms_running / 1000;
1244
1245 #else
1246
1247 time_t sec_run = ms_running / 1000;
1248
1249 #endif
1250
1251 if (sec_run)
1252 {
1253 char display_run[32] = { 0 };
1254
1255 struct tm tm_run;
1256
1257 struct tm *tmp = NULL;
1258
1259 #ifdef WIN
1260
1261 tmp = _gmtime64 (&sec_run);
1262
1263 #else
1264
1265 tmp = gmtime (&sec_run);
1266
1267 #endif
1268
1269 if (tmp != NULL)
1270 {
1271 memset (&tm_run, 0, sizeof (tm_run));
1272
1273 memcpy (&tm_run, tmp, sizeof (tm_run));
1274
1275 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1276
1277 char *start = ctime (&data.proc_start);
1278
1279 size_t start_len = strlen (start);
1280
1281 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1282 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1283
1284 log_info ("Time.Started...: %s (%s)", start, display_run);
1285 }
1286 }
1287 else
1288 {
1289 log_info ("Time.Started...: 0 secs");
1290 }
1291
1292 /**
1293 * counters
1294 */
1295
1296 uint salts_left = data.salts_cnt - data.salts_done;
1297
1298 if (salts_left == 0) salts_left = 1;
1299
1300 u64 progress_total = data.words_cnt * salts_left;
1301
1302 u64 all_done = 0;
1303 u64 all_rejected = 0;
1304 u64 all_restored = 0;
1305
1306 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1307 {
1308 if (salts_left > 1)
1309 {
1310 // otherwise the final cracked status shows 0/XXX progress
1311
1312 if (data.salts_shown[salt_pos] == 1) continue;
1313 }
1314
1315 all_done += data.words_progress_done[salt_pos];
1316 all_rejected += data.words_progress_rejected[salt_pos];
1317 all_restored += data.words_progress_restored[salt_pos];
1318 }
1319
1320 u64 progress_cur = all_restored + all_done + all_rejected;
1321 u64 progress_end = progress_total;
1322
1323 u64 progress_skip = 0;
1324
1325 if (data.skip)
1326 {
1327 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1328
1329 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1330 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1331 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1332 }
1333
1334 if (data.limit)
1335 {
1336 progress_end = MIN (data.limit, data.words_base) * salts_left;
1337
1338 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1339 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1340 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1341 }
1342
1343 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1344 u64 progress_end_relative_skip = progress_end - progress_skip;
1345
1346 float speed_ms_real = ms_running - ms_paused;
1347 u64 speed_plains_real = all_done;
1348
1349 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1350 {
1351 if (data.devices_status != STATUS_CRACKED)
1352 {
1353 u64 words_per_ms = 0;
1354
1355 if (speed_plains_real && speed_ms_real)
1356 {
1357 words_per_ms = speed_plains_real / speed_ms_real;
1358 }
1359
1360 #ifdef WIN
1361 __time64_t sec_etc = 0;
1362 #else
1363 time_t sec_etc = 0;
1364 #endif
1365
1366 if (words_per_ms)
1367 {
1368 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1369
1370 u64 ms_left = progress_left_relative_skip / words_per_ms;
1371
1372 sec_etc = ms_left / 1000;
1373 }
1374
1375 if (sec_etc == 0)
1376 {
1377 log_info ("Time.Estimated.: 0 secs");
1378 }
1379 else if ((u64) sec_etc > ETC_MAX)
1380 {
1381 log_info ("Time.Estimated.: > 10 Years");
1382 }
1383 else
1384 {
1385 char display_etc[32] = { 0 };
1386
1387 struct tm tm_etc;
1388
1389 struct tm *tmp = NULL;
1390
1391 #ifdef WIN
1392
1393 tmp = _gmtime64 (&sec_etc);
1394
1395 #else
1396
1397 tmp = gmtime (&sec_etc);
1398
1399 #endif
1400
1401 if (tmp != NULL)
1402 {
1403 memset (&tm_etc, 0, sizeof (tm_etc));
1404
1405 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1406
1407 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1408
1409 time_t now;
1410
1411 time (&now);
1412
1413 now += sec_etc;
1414
1415 char *etc = ctime (&now);
1416
1417 size_t etc_len = strlen (etc);
1418
1419 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1420 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1421
1422 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1423 }
1424 }
1425 }
1426 }
1427
1428 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1429 {
1430 hc_device_param_t *device_param = &data.devices_param[device_id];
1431
1432 if (device_param->skipped) continue;
1433
1434 char display_dev_cur[16] = { 0 };
1435
1436 strncpy (display_dev_cur, "0.00", 4);
1437
1438 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1439
1440 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1441 }
1442
1443 char display_all_cur[16] = { 0 };
1444
1445 strncpy (display_all_cur, "0.00", 4);
1446
1447 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1448
1449 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1450
1451 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1452 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1453
1454 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);
1455
1456 // crack-per-time
1457
1458 if (data.digests_cnt > 100)
1459 {
1460 time_t now = time (NULL);
1461
1462 int cpt_cur_min = 0;
1463 int cpt_cur_hour = 0;
1464 int cpt_cur_day = 0;
1465
1466 for (int i = 0; i < CPT_BUF; i++)
1467 {
1468 const uint cracked = data.cpt_buf[i].cracked;
1469 const time_t timestamp = data.cpt_buf[i].timestamp;
1470
1471 if ((timestamp + 60) > now)
1472 {
1473 cpt_cur_min += cracked;
1474 }
1475
1476 if ((timestamp + 3600) > now)
1477 {
1478 cpt_cur_hour += cracked;
1479 }
1480
1481 if ((timestamp + 86400) > now)
1482 {
1483 cpt_cur_day += cracked;
1484 }
1485 }
1486
1487 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1488 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1489 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1490
1491 if ((data.cpt_start + 86400) < now)
1492 {
1493 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1494 cpt_cur_min,
1495 cpt_cur_hour,
1496 cpt_cur_day,
1497 cpt_avg_min,
1498 cpt_avg_hour,
1499 cpt_avg_day);
1500 }
1501 else if ((data.cpt_start + 3600) < now)
1502 {
1503 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1504 cpt_cur_min,
1505 cpt_cur_hour,
1506 cpt_avg_min,
1507 cpt_avg_hour,
1508 cpt_avg_day);
1509 }
1510 else if ((data.cpt_start + 60) < now)
1511 {
1512 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1513 cpt_cur_min,
1514 cpt_avg_min,
1515 cpt_avg_hour,
1516 cpt_avg_day);
1517 }
1518 else
1519 {
1520 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1521 cpt_avg_min,
1522 cpt_avg_hour,
1523 cpt_avg_day);
1524 }
1525 }
1526
1527 // Restore point
1528
1529 u64 restore_point = get_lowest_words_done ();
1530
1531 u64 restore_total = data.words_base;
1532
1533 float percent_restore = 0;
1534
1535 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1536
1537 if (progress_end_relative_skip)
1538 {
1539 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1540 {
1541 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1542 float percent_rejected = 0.0;
1543
1544 if (progress_cur)
1545 {
1546 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1547 }
1548
1549 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);
1550 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1551
1552 if (data.restore_disable == 0)
1553 {
1554 if (percent_finished != 1)
1555 {
1556 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1557 }
1558 }
1559 }
1560 }
1561 else
1562 {
1563 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1564 {
1565 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1566 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1567
1568 if (data.restore_disable == 0)
1569 {
1570 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1571 }
1572 }
1573 else
1574 {
1575 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1576 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1577
1578 // --restore not allowed if stdin is used -- really? why?
1579
1580 //if (data.restore_disable == 0)
1581 //{
1582 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1583 //}
1584 }
1585 }
1586
1587 #ifdef HAVE_HWMON
1588 if (data.gpu_temp_disable == 0)
1589 {
1590 hc_thread_mutex_lock (mux_adl);
1591
1592 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1593 {
1594 hc_device_param_t *device_param = &data.devices_param[device_id];
1595
1596 if (device_param->skipped) continue;
1597
1598 #define HM_STR_BUF_SIZE 255
1599
1600 if (data.hm_device[device_id].fan_supported == 1)
1601 {
1602 char utilization[HM_STR_BUF_SIZE] = { 0 };
1603 char temperature[HM_STR_BUF_SIZE] = { 0 };
1604 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1605
1606 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1607 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1608
1609 if (device_param->vendor_id == VENDOR_ID_AMD)
1610 {
1611 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1612 }
1613 else if (device_param->vendor_id == VENDOR_ID_NV)
1614 {
1615 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1616 }
1617
1618 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1619 }
1620 else
1621 {
1622 char utilization[HM_STR_BUF_SIZE] = { 0 };
1623 char temperature[HM_STR_BUF_SIZE] = { 0 };
1624
1625 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1626 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1627
1628 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1629 }
1630 }
1631
1632 hc_thread_mutex_unlock (mux_adl);
1633 }
1634 #endif // HAVE_HWMON
1635 }
1636
1637 static void status_benchmark ()
1638 {
1639 if (data.devices_status == STATUS_INIT) return;
1640 if (data.devices_status == STATUS_STARTING) return;
1641
1642 if (data.words_cnt == 0) return;
1643
1644 u64 speed_cnt[DEVICES_MAX] = { 0 };
1645 float speed_ms[DEVICES_MAX] = { 0 };
1646
1647 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1648 {
1649 hc_device_param_t *device_param = &data.devices_param[device_id];
1650
1651 if (device_param->skipped) continue;
1652
1653 speed_cnt[device_id] = 0;
1654 speed_ms[device_id] = 0;
1655
1656 for (int i = 0; i < SPEED_CACHE; i++)
1657 {
1658 speed_cnt[device_id] += device_param->speed_cnt[i];
1659 speed_ms[device_id] += device_param->speed_ms[i];
1660 }
1661
1662 speed_cnt[device_id] /= SPEED_CACHE;
1663 speed_ms[device_id] /= SPEED_CACHE;
1664 }
1665
1666 float hashes_all_ms = 0;
1667
1668 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1669
1670 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1671 {
1672 hc_device_param_t *device_param = &data.devices_param[device_id];
1673
1674 if (device_param->skipped) continue;
1675
1676 hashes_dev_ms[device_id] = 0;
1677
1678 if (speed_ms[device_id])
1679 {
1680 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1681
1682 hashes_all_ms += hashes_dev_ms[device_id];
1683 }
1684 }
1685
1686 /**
1687 * exec time
1688 */
1689
1690 double exec_all_ms[DEVICES_MAX] = { 0 };
1691
1692 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1693 {
1694 hc_device_param_t *device_param = &data.devices_param[device_id];
1695
1696 if (device_param->skipped) continue;
1697
1698 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1699
1700 exec_all_ms[device_id] = exec_ms_avg;
1701 }
1702
1703 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1704 {
1705 hc_device_param_t *device_param = &data.devices_param[device_id];
1706
1707 if (device_param->skipped) continue;
1708
1709 char display_dev_cur[16] = { 0 };
1710
1711 strncpy (display_dev_cur, "0.00", 4);
1712
1713 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1714
1715 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1716 }
1717
1718 char display_all_cur[16] = { 0 };
1719
1720 strncpy (display_all_cur, "0.00", 4);
1721
1722 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1723
1724 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1725 }
1726
1727 /**
1728 * oclHashcat -only- functions
1729 */
1730
1731 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1732 {
1733 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1734 {
1735 if (attack_kern == ATTACK_KERN_STRAIGHT)
1736 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1737 else if (attack_kern == ATTACK_KERN_COMBI)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_BF)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1741 }
1742 else
1743 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1744 }
1745
1746 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1747 {
1748 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1749 {
1750 if (attack_kern == ATTACK_KERN_STRAIGHT)
1751 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1752 else if (attack_kern == ATTACK_KERN_COMBI)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_BF)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 }
1757 else
1758 {
1759 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1760 }
1761 }
1762
1763 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1764 {
1765 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1766 {
1767 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1768 }
1769 else
1770 {
1771 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1772 }
1773 }
1774
1775 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1776 {
1777 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1778 {
1779 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1788 {
1789 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1790 }
1791
1792 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1793 {
1794 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1795 }
1796
1797 static uint convert_from_hex (char *line_buf, const uint line_len)
1798 {
1799 if (line_len & 1) return (line_len); // not in hex
1800
1801 if (data.hex_wordlist == 1)
1802 {
1803 uint i;
1804 uint j;
1805
1806 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1807 {
1808 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1809 }
1810
1811 memset (line_buf + i, 0, line_len - i);
1812
1813 return (i);
1814 }
1815 else if (line_len >= 6) // $HEX[] = 6
1816 {
1817 if (line_buf[0] != '$') return (line_len);
1818 if (line_buf[1] != 'H') return (line_len);
1819 if (line_buf[2] != 'E') return (line_len);
1820 if (line_buf[3] != 'X') return (line_len);
1821 if (line_buf[4] != '[') return (line_len);
1822 if (line_buf[line_len - 1] != ']') return (line_len);
1823
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836
1837 return (line_len);
1838 }
1839
1840 static void clear_prompt ()
1841 {
1842 fputc ('\r', stdout);
1843
1844 for (size_t i = 0; i < strlen (PROMPT); i++)
1845 {
1846 fputc (' ', stdout);
1847 }
1848
1849 fputc ('\r', stdout);
1850
1851 fflush (stdout);
1852 }
1853
1854 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1855 {
1856 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1857 }
1858
1859 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1860 {
1861 char *outfile = data.outfile;
1862 uint quiet = data.quiet;
1863 FILE *pot_fp = data.pot_fp;
1864 uint loopback = data.loopback;
1865 uint debug_mode = data.debug_mode;
1866 char *debug_file = data.debug_file;
1867
1868 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1869 int debug_rule_len = 0; // -1 error
1870 uint debug_plain_len = 0;
1871
1872 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1873
1874 // hash
1875
1876 char out_buf[4096] = { 0 };
1877
1878 ascii_digest (out_buf, salt_pos, digest_pos);
1879
1880 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1881
1882 // plain
1883
1884 plain_t plain;
1885
1886 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1887
1888 uint gidvid = plain.gidvid;
1889 uint il_pos = plain.il_pos;
1890
1891 u64 crackpos = device_param->words_off;
1892
1893 uint plain_buf[16] = { 0 };
1894
1895 u8 *plain_ptr = (u8 *) plain_buf;
1896 unsigned int plain_len = 0;
1897
1898 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1899 {
1900 u64 gidd = gidvid;
1901 u64 gidm = 0;
1902
1903 pw_t pw;
1904
1905 gidd_to_pw_t (device_param, gidd, &pw);
1906
1907 for (int i = 0, j = gidm; i < 16; i++, j++)
1908 {
1909 plain_buf[i] = pw.h.hi1[0][j];
1910 }
1911
1912 plain_len = pw.pw_len;
1913
1914 const uint off = device_param->innerloop_pos + il_pos;
1915
1916 if (debug_mode > 0)
1917 {
1918 debug_rule_len = 0;
1919
1920 // save rule
1921 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1922 {
1923 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1924
1925 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1926 }
1927
1928 // save plain
1929 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1930 {
1931 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1932
1933 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1934
1935 debug_plain_len = plain_len;
1936 }
1937 }
1938
1939 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1940
1941 crackpos += gidvid;
1942 crackpos *= data.kernel_rules_cnt;
1943 crackpos += device_param->innerloop_pos + il_pos;
1944
1945 if (plain_len > data.pw_max) plain_len = data.pw_max;
1946 }
1947 else if (data.attack_mode == ATTACK_MODE_COMBI)
1948 {
1949 u64 gidd = gidvid;
1950 u64 gidm = 0;
1951
1952 pw_t pw;
1953
1954 gidd_to_pw_t (device_param, gidd, &pw);
1955
1956 for (int i = 0, j = gidm; i < 16; i++, j++)
1957 {
1958 plain_buf[i] = pw.h.hi1[0][j];
1959 }
1960
1961 plain_len = pw.pw_len;
1962
1963 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1964 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1965
1966 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1967 {
1968 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1969 }
1970 else
1971 {
1972 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1973
1974 memcpy (plain_ptr, comb_buf, comb_len);
1975 }
1976
1977 plain_len += comb_len;
1978
1979 crackpos += gidvid;
1980 crackpos *= data.combs_cnt;
1981 crackpos += device_param->innerloop_pos + il_pos;
1982
1983 if (data.pw_max != PW_DICTMAX1)
1984 {
1985 if (plain_len > data.pw_max) plain_len = data.pw_max;
1986 }
1987 }
1988 else if (data.attack_mode == ATTACK_MODE_BF)
1989 {
1990 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1991 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1992
1993 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1994 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1995
1996 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1997 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1998
1999 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2000 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2001
2002 plain_len = data.css_cnt;
2003
2004 crackpos += gidvid;
2005 crackpos *= data.bfs_cnt;
2006 crackpos += device_param->innerloop_pos + il_pos;
2007 }
2008 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2009 {
2010 u64 gidd = gidvid;
2011 u64 gidm = 0;
2012
2013 pw_t pw;
2014
2015 gidd_to_pw_t (device_param, gidd, &pw);
2016
2017 for (int i = 0, j = gidm; i < 16; i++, j++)
2018 {
2019 plain_buf[i] = pw.h.hi1[0][j];
2020 }
2021
2022 plain_len = pw.pw_len;
2023
2024 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2025
2026 uint start = 0;
2027 uint stop = device_param->kernel_params_mp_buf32[4];
2028
2029 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2030
2031 plain_len += start + stop;
2032
2033 crackpos += gidvid;
2034 crackpos *= data.combs_cnt;
2035 crackpos += device_param->innerloop_pos + il_pos;
2036
2037 if (data.pw_max != PW_DICTMAX1)
2038 {
2039 if (plain_len > data.pw_max) plain_len = data.pw_max;
2040 }
2041 }
2042 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2043 {
2044 u64 gidd = gidvid;
2045 u64 gidm = 0;
2046
2047 pw_t pw;
2048
2049 gidd_to_pw_t (device_param, gidd, &pw);
2050
2051 for (int i = 0, j = gidm; i < 16; i++, j++)
2052 {
2053 plain_buf[i] = pw.h.hi1[0][j];
2054 }
2055
2056 plain_len = pw.pw_len;
2057
2058 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2059
2060 uint start = 0;
2061 uint stop = device_param->kernel_params_mp_buf32[4];
2062
2063 memmove (plain_ptr + stop, plain_ptr, plain_len);
2064
2065 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2066
2067 plain_len += start + stop;
2068
2069 crackpos += gidvid;
2070 crackpos *= data.combs_cnt;
2071 crackpos += device_param->innerloop_pos + il_pos;
2072
2073 if (data.pw_max != PW_DICTMAX1)
2074 {
2075 if (plain_len > data.pw_max) plain_len = data.pw_max;
2076 }
2077 }
2078
2079 if (data.attack_mode == ATTACK_MODE_BF)
2080 {
2081 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2082 {
2083 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2084 {
2085 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2086 {
2087 plain_len = plain_len - data.salts_buf[0].salt_len;
2088 }
2089 }
2090
2091 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2092 {
2093 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2094 {
2095 plain_ptr[j] = plain_ptr[i];
2096 }
2097
2098 plain_len = plain_len / 2;
2099 }
2100 }
2101 }
2102
2103 // if enabled, update also the potfile
2104
2105 if (pot_fp)
2106 {
2107 lock_file (pot_fp);
2108
2109 fprintf (pot_fp, "%s:", out_buf);
2110
2111 format_plain (pot_fp, plain_ptr, plain_len, 1);
2112
2113 fputc ('\n', pot_fp);
2114
2115 fflush (pot_fp);
2116
2117 unlock_file (pot_fp);
2118 }
2119
2120 // outfile
2121
2122 FILE *out_fp = NULL;
2123
2124 if (outfile != NULL)
2125 {
2126 if ((out_fp = fopen (outfile, "ab")) == NULL)
2127 {
2128 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2129
2130 out_fp = stdout;
2131 }
2132 lock_file (out_fp);
2133 }
2134 else
2135 {
2136 out_fp = stdout;
2137
2138 if (quiet == 0) clear_prompt ();
2139 }
2140
2141 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2142
2143 if (outfile != NULL)
2144 {
2145 if (out_fp != stdout)
2146 {
2147 fclose (out_fp);
2148 }
2149 }
2150 else
2151 {
2152 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2153 {
2154 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2155 {
2156 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2157 if (quiet == 0) fflush (stdout);
2158 }
2159 }
2160 }
2161
2162 // loopback
2163
2164 if (loopback)
2165 {
2166 char *loopback_file = data.loopback_file;
2167
2168 FILE *fb_fp = NULL;
2169
2170 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2171 {
2172 lock_file (fb_fp);
2173
2174 format_plain (fb_fp, plain_ptr, plain_len, 1);
2175
2176 fputc ('\n', fb_fp);
2177
2178 fclose (fb_fp);
2179 }
2180 }
2181
2182 // (rule) debug mode
2183
2184 // the next check implies that:
2185 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2186 // - debug_mode > 0
2187
2188 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2189 {
2190 if (debug_rule_len < 0) debug_rule_len = 0;
2191
2192 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2193
2194 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2195
2196 if ((quiet == 0) && (debug_file == NULL))
2197 {
2198 fprintf (stdout, "%s", PROMPT);
2199 fflush (stdout);
2200 }
2201 }
2202 }
2203
2204 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2205 {
2206 salt_t *salt_buf = &data.salts_buf[salt_pos];
2207
2208 int found = 0;
2209
2210 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2211
2212 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2213
2214 if (found == 1)
2215 {
2216 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2217
2218 log_info_nn ("");
2219
2220 hc_clEnqueueReadBuffer (data.ocl, 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);
2221
2222 uint cpt_cracked = 0;
2223
2224 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2225 {
2226 uint idx = salt_buf->digests_offset + digest_pos;
2227
2228 if (data.digests_shown_tmp[idx] == 0) continue;
2229
2230 if (data.digests_shown[idx] == 1) continue;
2231
2232 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2233 {
2234 data.digests_shown[idx] = 1;
2235
2236 data.digests_done++;
2237
2238 cpt_cracked++;
2239
2240 salt_buf->digests_done++;
2241
2242 if (salt_buf->digests_done == salt_buf->digests_cnt)
2243 {
2244 data.salts_shown[salt_pos] = 1;
2245
2246 data.salts_done++;
2247 }
2248 }
2249
2250 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2251
2252 check_hash (device_param, salt_pos, digest_pos);
2253 }
2254
2255 if (cpt_cracked > 0)
2256 {
2257 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2258 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2259
2260 data.cpt_pos++;
2261
2262 data.cpt_total += cpt_cracked;
2263
2264 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2265 }
2266
2267 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2268 {
2269 // we need to reset cracked state on the device
2270 // otherwise host thinks again and again the hash was cracked
2271 // and returns invalid password each time
2272
2273 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2274
2275 hc_clEnqueueWriteBuffer (data.ocl, 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);
2276 }
2277
2278 memset (device_param->result, 0, device_param->size_results);
2279
2280 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2281 }
2282 }
2283
2284 static void save_hash ()
2285 {
2286 char *hashfile = data.hashfile;
2287
2288 char new_hashfile[256] = { 0 };
2289 char old_hashfile[256] = { 0 };
2290
2291 snprintf (new_hashfile, 255, "%s.new", hashfile);
2292 snprintf (old_hashfile, 255, "%s.old", hashfile);
2293
2294 unlink (new_hashfile);
2295
2296 char separator = data.separator;
2297
2298 FILE *fp = fopen (new_hashfile, "wb");
2299
2300 if (fp == NULL)
2301 {
2302 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2303
2304 exit (-1);
2305 }
2306
2307 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2308 {
2309 if (data.salts_shown[salt_pos] == 1) continue;
2310
2311 salt_t *salt_buf = &data.salts_buf[salt_pos];
2312
2313 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2314 {
2315 uint idx = salt_buf->digests_offset + digest_pos;
2316
2317 if (data.digests_shown[idx] == 1) continue;
2318
2319 if (data.hash_mode != 2500)
2320 {
2321 char out_buf[4096] = { 0 };
2322
2323 if (data.username == 1)
2324 {
2325 user_t *user = data.hash_info[idx]->user;
2326
2327 uint i;
2328
2329 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2330
2331 fputc (separator, fp);
2332 }
2333
2334 ascii_digest (out_buf, salt_pos, digest_pos);
2335
2336 fputs (out_buf, fp);
2337
2338 log_out (fp, "");
2339 }
2340 else
2341 {
2342 hccap_t hccap;
2343
2344 to_hccap_t (&hccap, salt_pos, digest_pos);
2345
2346 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2347 }
2348 }
2349 }
2350
2351 fflush (fp);
2352
2353 fclose (fp);
2354
2355 unlink (old_hashfile);
2356
2357 if (rename (hashfile, old_hashfile) != 0)
2358 {
2359 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2360
2361 exit (-1);
2362 }
2363
2364 unlink (hashfile);
2365
2366 if (rename (new_hashfile, hashfile) != 0)
2367 {
2368 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2369
2370 exit (-1);
2371 }
2372
2373 unlink (old_hashfile);
2374 }
2375
2376 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2377 {
2378 // function called only in case kernel_power_all > words_left
2379
2380 float kernel_power_div = (float) (total_left) / kernel_power_all;
2381
2382 kernel_power_div += kernel_power_div / 100;
2383
2384 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2385
2386 while (kernel_power_new < total_left)
2387 {
2388 kernel_power_div += kernel_power_div / 100;
2389
2390 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2391 }
2392
2393 if (data.quiet == 0)
2394 {
2395 clear_prompt ();
2396
2397 log_info ("");
2398
2399 log_info ("INFO: approaching final keyspace, workload adjusted");
2400
2401 log_info ("");
2402
2403 fprintf (stdout, "%s", PROMPT);
2404
2405 fflush (stdout);
2406 }
2407
2408 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2409
2410 return kernel_power_div;
2411 }
2412
2413 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2414 {
2415 uint num_elements = num;
2416
2417 device_param->kernel_params_buf32[30] = data.combs_mode;
2418 device_param->kernel_params_buf32[31] = num;
2419
2420 uint kernel_threads = device_param->kernel_threads;
2421
2422 while (num_elements % kernel_threads) num_elements++;
2423
2424 cl_kernel kernel = NULL;
2425
2426 switch (kern_run)
2427 {
2428 case KERN_RUN_1: kernel = device_param->kernel1; break;
2429 case KERN_RUN_12: kernel = device_param->kernel12; break;
2430 case KERN_RUN_2: kernel = device_param->kernel2; break;
2431 case KERN_RUN_23: kernel = device_param->kernel23; break;
2432 case KERN_RUN_3: kernel = device_param->kernel3; break;
2433 }
2434
2435 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2436 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2437 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2438 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2439 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2440 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2441 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2442 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2443 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2444 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2445 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2446
2447 hc_timer_t timer;
2448
2449 hc_timer_set (&timer);
2450
2451 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2452 {
2453 const size_t global_work_size[3] = { num_elements, 32, 1 };
2454 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2455
2456 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2457 }
2458 else
2459 {
2460 size_t workgroup_size = 0;
2461
2462 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2463
2464 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2465
2466 const size_t global_work_size[3] = { num_elements, 1, 1 };
2467 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2468
2469 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2470 }
2471
2472 hc_clFlush (data.ocl, device_param->command_queue);
2473
2474 hc_clFinish (data.ocl, device_param->command_queue);
2475
2476 if (event_update)
2477 {
2478 float exec_time;
2479
2480 hc_timer_get (timer, exec_time);
2481
2482 uint exec_pos = device_param->exec_pos;
2483
2484 device_param->exec_ms[exec_pos] = exec_time;
2485
2486 exec_pos++;
2487
2488 if (exec_pos == EXEC_CACHE)
2489 {
2490 exec_pos = 0;
2491 }
2492
2493 device_param->exec_pos = exec_pos;
2494 }
2495 }
2496
2497 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2498 {
2499 uint num_elements = num;
2500
2501 switch (kern_run)
2502 {
2503 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2504 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2505 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2506 }
2507
2508 // causes problems with special threads like in bcrypt
2509 // const uint kernel_threads = device_param->kernel_threads;
2510
2511 uint kernel_threads = KERNEL_THREADS;
2512
2513 while (num_elements % kernel_threads) num_elements++;
2514
2515 cl_kernel kernel = NULL;
2516
2517 switch (kern_run)
2518 {
2519 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2520 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2521 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2522 }
2523
2524 switch (kern_run)
2525 {
2526 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2527 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2528 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2529 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2530 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2531 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2532 break;
2533 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2534 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2535 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2536 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2537 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2538 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2539 break;
2540 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2541 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2542 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2543 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2544 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2545 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2546 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2547 break;
2548 }
2549
2550 size_t workgroup_size = 0;
2551 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2552 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2553
2554 const size_t global_work_size[3] = { num_elements, 1, 1 };
2555 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2556
2557 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2558
2559 hc_clFlush (data.ocl, device_param->command_queue);
2560
2561 hc_clFinish (data.ocl, device_param->command_queue);
2562 }
2563
2564 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2565 {
2566 uint num_elements = num;
2567
2568 uint kernel_threads = device_param->kernel_threads;
2569
2570 while (num_elements % kernel_threads) num_elements++;
2571
2572 cl_kernel kernel = device_param->kernel_tb;
2573
2574 size_t workgroup_size = 0;
2575 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2576 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2577
2578 const size_t global_work_size[3] = { num_elements, 1, 1 };
2579 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2580
2581 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2582
2583 hc_clFlush (data.ocl, device_param->command_queue);
2584
2585 hc_clFinish (data.ocl, device_param->command_queue);
2586 }
2587
2588 static void run_kernel_tm (hc_device_param_t *device_param)
2589 {
2590 const uint num_elements = 1024; // fixed
2591
2592 uint kernel_threads = 32;
2593
2594 cl_kernel kernel = device_param->kernel_tm;
2595
2596 size_t workgroup_size = 0;
2597 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2598 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2599
2600 const size_t global_work_size[3] = { num_elements, 1, 1 };
2601 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2602
2603 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2604
2605 hc_clFlush (data.ocl, device_param->command_queue);
2606
2607 hc_clFinish (data.ocl, device_param->command_queue);
2608 }
2609
2610 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2611 {
2612 uint num_elements = num;
2613
2614 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2615 device_param->kernel_params_amp_buf32[6] = num_elements;
2616
2617 // causes problems with special threads like in bcrypt
2618 // const uint kernel_threads = device_param->kernel_threads;
2619
2620 uint kernel_threads = KERNEL_THREADS;
2621
2622 while (num_elements % kernel_threads) num_elements++;
2623
2624 cl_kernel kernel = device_param->kernel_amp;
2625
2626 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2627 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2628
2629 size_t workgroup_size = 0;
2630 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2631 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2632
2633 const size_t global_work_size[3] = { num_elements, 1, 1 };
2634 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2635
2636 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2637
2638 hc_clFlush (data.ocl, device_param->command_queue);
2639
2640 hc_clFinish (data.ocl, device_param->command_queue);
2641 }
2642
2643 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2644 {
2645 int rc = -1;
2646
2647 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2648 {
2649 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2650
2651 const cl_uchar zero = 0;
2652
2653 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2654 }
2655
2656 if (rc != 0)
2657 {
2658 // NOTE: clEnqueueFillBuffer () always fails with -59
2659 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2660 // How's that possible, OpenCL 1.2 support is advertised??
2661 // We need to workaround...
2662
2663 #define FILLSZ 0x100000
2664
2665 char *tmp = (char *) mymalloc (FILLSZ);
2666
2667 for (uint i = 0; i < size; i += FILLSZ)
2668 {
2669 const int left = size - i;
2670
2671 const int fillsz = MIN (FILLSZ, left);
2672
2673 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2674 }
2675
2676 myfree (tmp);
2677 }
2678 }
2679
2680 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2681 {
2682 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2683 {
2684 if (attack_mode == ATTACK_MODE_BF)
2685 {
2686 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2687 {
2688 const uint size_tm = 32 * sizeof (bs_word_t);
2689
2690 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2691
2692 run_kernel_tm (device_param);
2693
2694 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2695 }
2696 }
2697
2698 if (highest_pw_len < 16)
2699 {
2700 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2701 }
2702 else if (highest_pw_len < 32)
2703 {
2704 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2705 }
2706 else
2707 {
2708 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2709 }
2710 }
2711 else
2712 {
2713 run_kernel_amp (device_param, pws_cnt);
2714
2715 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2716
2717 if (opts_type & OPTS_TYPE_HOOK12)
2718 {
2719 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2720 }
2721
2722 uint iter = salt_buf->salt_iter;
2723
2724 uint loop_step = device_param->kernel_loops;
2725
2726 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2727 {
2728 uint loop_left = iter - loop_pos;
2729
2730 loop_left = MIN (loop_left, loop_step);
2731
2732 device_param->kernel_params_buf32[25] = loop_pos;
2733 device_param->kernel_params_buf32[26] = loop_left;
2734
2735 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2736
2737 if (data.devices_status == STATUS_CRACKED) break;
2738 if (data.devices_status == STATUS_ABORTED) break;
2739 if (data.devices_status == STATUS_QUIT) break;
2740 }
2741
2742 if (opts_type & OPTS_TYPE_HOOK23)
2743 {
2744 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2745
2746 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2747
2748 // do something with data
2749
2750 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2751 }
2752
2753 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2754 }
2755 }
2756
2757 static int run_rule_engine (const int rule_len, const char *rule_buf)
2758 {
2759 if (rule_len == 0)
2760 {
2761 return 0;
2762 }
2763 else if (rule_len == 1)
2764 {
2765 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2766 }
2767
2768 return 1;
2769 }
2770
2771 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2772 {
2773 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2774 {
2775 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2776 }
2777 else if (data.attack_kern == ATTACK_KERN_COMBI)
2778 {
2779 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2780 }
2781 else if (data.attack_kern == ATTACK_KERN_BF)
2782 {
2783 const u64 off = device_param->words_off;
2784
2785 device_param->kernel_params_mp_l_buf64[3] = off;
2786
2787 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2788 }
2789 }
2790
2791 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2792 {
2793 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2794
2795 device_param->kernel_params_buf32[26] = kernel_loops;
2796 device_param->kernel_params_buf32[27] = kernel_loops;
2797
2798 // init some fake words
2799
2800 if (data.attack_kern == ATTACK_KERN_BF)
2801 {
2802 run_kernel_mp (KERN_RUN_MP_L, device_param, kernel_power);
2803 run_kernel_mp (KERN_RUN_MP_R, device_param, kernel_loops);
2804 }
2805 else
2806 {
2807 for (u32 i = 0; i < kernel_power; i++)
2808 {
2809 device_param->pws_buf[i].pw_len = i & 7;
2810 }
2811
2812 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2813
2814 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2815 {
2816 run_kernel_amp (device_param, kernel_power);
2817 }
2818 }
2819
2820 // caching run
2821
2822 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2823 {
2824 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2825 }
2826 else
2827 {
2828 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2829 }
2830
2831 // now user repeats
2832
2833 for (int i = 0; i < repeat; i++)
2834 {
2835 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2836 {
2837 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2838 }
2839 else
2840 {
2841 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2842 }
2843 }
2844
2845 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2846
2847 // reset fake words
2848
2849 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2850
2851 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2852 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2853
2854 return exec_ms_prev;
2855 }
2856
2857 static void autotune (hc_device_param_t *device_param)
2858 {
2859 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2860
2861 const u32 kernel_accel_min = device_param->kernel_accel_min;
2862 const u32 kernel_accel_max = device_param->kernel_accel_max;
2863
2864 const u32 kernel_loops_min = device_param->kernel_loops_min;
2865 const u32 kernel_loops_max = device_param->kernel_loops_max;
2866
2867 u32 kernel_accel = kernel_accel_min;
2868 u32 kernel_loops = kernel_loops_min;
2869
2870 // steps
2871
2872 #define STEPS_CNT 10
2873
2874 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2875 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2876
2877 u32 steps_accel[STEPS_ACCEL_CNT];
2878 u32 steps_loops[STEPS_LOOPS_CNT];
2879
2880 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2881 {
2882 steps_accel[i] = 1 << i;
2883 }
2884
2885 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2886 {
2887 steps_loops[i] = 1 << i;
2888 }
2889
2890 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2891 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2892
2893 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2894 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2895
2896 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2897 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2898
2899 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2900
2901 u32 kernel_loops_tmp;
2902
2903 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2904 {
2905 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2906
2907 if (exec_ms < target_ms) break;
2908 }
2909
2910 // kernel-accel
2911
2912 if (kernel_accel_min < kernel_accel_max)
2913 {
2914 double e_best = 0;
2915
2916 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2917 {
2918 const u32 kernel_accel_try = steps_accel[i];
2919
2920 if (kernel_accel_try < kernel_accel_min) continue;
2921 if (kernel_accel_try > kernel_accel_max) break;
2922
2923 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2924
2925 if (exec_ms > target_ms) break;
2926
2927 const double e = kernel_accel_try / exec_ms;
2928
2929 if (e > e_best)
2930 {
2931 kernel_accel = kernel_accel_try;
2932
2933 e_best = e;
2934 }
2935 }
2936 }
2937
2938 // kernel-loops final
2939
2940 if (kernel_loops_min < kernel_loops_max)
2941 {
2942 double e_best = 0;
2943
2944 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2945 {
2946 const u32 kernel_loops_try = steps_loops[i];
2947
2948 if (kernel_loops_try < kernel_loops_min) continue;
2949 if (kernel_loops_try > kernel_loops_max) break;
2950
2951 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2952
2953 if (exec_ms > target_ms) break;
2954
2955 const double e = kernel_loops_try / exec_ms;
2956
2957 if (e > e_best)
2958 {
2959 kernel_loops = kernel_loops_try;
2960
2961 e_best = e;
2962 }
2963 }
2964 }
2965
2966 // final balance
2967
2968 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops, 1);
2969
2970 u32 kernel_accel_best = kernel_accel;
2971 u32 kernel_loops_best = kernel_loops;
2972
2973 u32 exec_best = exec_ms;
2974
2975 // reset
2976
2977 if (kernel_accel_min < kernel_accel_max)
2978 {
2979 u32 kernel_accel_try = kernel_accel;
2980 u32 kernel_loops_try = kernel_loops;
2981
2982 for (int i = 0; i < 2; i++)
2983 {
2984 kernel_accel_try >>= 1;
2985 kernel_loops_try <<= 1;
2986
2987 if (kernel_accel_try < kernel_accel_min) break;
2988 if (kernel_loops_try > kernel_loops_max) break;
2989
2990 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2991
2992 if (exec_ms < exec_best)
2993 {
2994 kernel_accel_best = kernel_accel_try;
2995 kernel_loops_best = kernel_loops_try;
2996
2997 exec_best = exec_ms;
2998 }
2999 }
3000
3001 kernel_accel = kernel_accel_best;
3002 kernel_loops = kernel_loops_best;
3003 }
3004
3005 // reset
3006
3007
3008 if (kernel_loops_min < kernel_loops_max)
3009 {
3010 u32 kernel_accel_try = kernel_accel;
3011 u32 kernel_loops_try = kernel_loops;
3012
3013 for (int i = 0; i < 2; i++)
3014 {
3015 kernel_accel_try <<= 1;
3016 kernel_loops_try >>= 1;
3017
3018 if (kernel_accel_try > kernel_accel_max) break;
3019 if (kernel_loops_try < kernel_loops_min) break;
3020
3021 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3022
3023 if (exec_ms < exec_best)
3024 {
3025 kernel_accel_best = kernel_accel_try;
3026 kernel_loops_best = kernel_loops_try;
3027
3028 exec_best = exec_ms;
3029 }
3030 }
3031
3032 kernel_accel = kernel_accel_best;
3033 kernel_loops = kernel_loops_best;
3034 }
3035
3036 // reset timer
3037
3038 device_param->exec_pos = 0;
3039
3040 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3041
3042 // store
3043
3044 device_param->kernel_loops = kernel_loops;
3045 device_param->kernel_accel = kernel_accel;
3046
3047 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3048
3049 device_param->kernel_power = kernel_power;
3050
3051 log_info ("Device #%u: autotuned kernel-accel to %u", device_param->device_id + 1, kernel_accel);
3052 log_info ("Device #%u: autotuned kernel-loops to %u", device_param->device_id + 1, kernel_loops);
3053 log_info ("");
3054 }
3055
3056 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
3057 {
3058 // init speed timer
3059
3060 uint speed_pos = device_param->speed_pos;
3061
3062 #ifdef _POSIX
3063 if (device_param->timer_speed.tv_sec == 0)
3064 {
3065 hc_timer_set (&device_param->timer_speed);
3066 }
3067 #endif
3068
3069 #ifdef _WIN
3070 if (device_param->timer_speed.QuadPart == 0)
3071 {
3072 hc_timer_set (&device_param->timer_speed);
3073 }
3074 #endif
3075
3076 // find higest password length, this is for optimization stuff
3077
3078 uint highest_pw_len = 0;
3079
3080 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3081 {
3082 }
3083 else if (data.attack_kern == ATTACK_KERN_COMBI)
3084 {
3085 }
3086 else if (data.attack_kern == ATTACK_KERN_BF)
3087 {
3088 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3089 + device_param->kernel_params_mp_l_buf32[5];
3090 }
3091
3092 // bitslice optimization stuff
3093
3094 if (data.attack_mode == ATTACK_MODE_BF)
3095 {
3096 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3097 {
3098 run_kernel_tb (device_param, pws_cnt);
3099 }
3100 }
3101
3102 // iteration type
3103
3104 uint innerloop_step = 0;
3105 uint innerloop_cnt = 0;
3106
3107 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3108 else innerloop_step = 1;
3109
3110 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3111 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3112 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3113
3114 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3115
3116 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3117 {
3118 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3119
3120 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3121
3122 if (data.devices_status == STATUS_CRACKED) break;
3123 if (data.devices_status == STATUS_ABORTED) break;
3124 if (data.devices_status == STATUS_QUIT) break;
3125 if (data.devices_status == STATUS_BYPASS) break;
3126
3127 if (data.salts_shown[salt_pos] == 1) continue;
3128
3129 salt_t *salt_buf = &data.salts_buf[salt_pos];
3130
3131 device_param->kernel_params_buf32[24] = salt_pos;
3132 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3133 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3134
3135 FILE *combs_fp = device_param->combs_fp;
3136
3137 if (data.attack_mode == ATTACK_MODE_COMBI)
3138 {
3139 rewind (combs_fp);
3140 }
3141
3142 // innerloops
3143
3144 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3145 {
3146 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3147
3148 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3149
3150 if (data.devices_status == STATUS_CRACKED) break;
3151 if (data.devices_status == STATUS_ABORTED) break;
3152 if (data.devices_status == STATUS_QUIT) break;
3153 if (data.devices_status == STATUS_BYPASS) break;
3154
3155 uint innerloop_left = innerloop_cnt - innerloop_pos;
3156
3157 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3158
3159 device_param->innerloop_pos = innerloop_pos;
3160 device_param->innerloop_left = innerloop_left;
3161
3162 device_param->kernel_params_buf32[27] = innerloop_left;
3163
3164 // i think we can get rid of this
3165 if (innerloop_left == 0)
3166 {
3167 puts ("bug, how should this happen????\n");
3168
3169 continue;
3170 }
3171
3172 // initialize amplifiers
3173
3174 if (data.attack_mode == ATTACK_MODE_COMBI)
3175 {
3176 char line_buf[BUFSIZ] = { 0 };
3177
3178 uint i = 0;
3179
3180 while (i < innerloop_left)
3181 {
3182 if (feof (combs_fp)) break;
3183
3184 int line_len = fgetl (combs_fp, line_buf);
3185
3186 if (line_len >= PW_MAX1) continue;
3187
3188 line_len = convert_from_hex (line_buf, line_len);
3189
3190 char *line_buf_new = line_buf;
3191
3192 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3193 {
3194 char rule_buf_out[BLOCK_SIZE] = { 0 };
3195
3196 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3197
3198 if (rule_len_out < 0)
3199 {
3200 data.words_progress_rejected[salt_pos] += pw_cnt;
3201
3202 continue;
3203 }
3204
3205 line_len = rule_len_out;
3206
3207 line_buf_new = rule_buf_out;
3208 }
3209
3210 line_len = MIN (line_len, PW_DICTMAX);
3211
3212 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3213
3214 memcpy (ptr, line_buf_new, line_len);
3215
3216 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3217
3218 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3219 {
3220 uppercase (ptr, line_len);
3221 }
3222
3223 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3224 {
3225 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3226 {
3227 ptr[line_len] = 0x80;
3228 }
3229
3230 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3231 {
3232 ptr[line_len] = 0x01;
3233 }
3234 }
3235
3236 device_param->combs_buf[i].pw_len = line_len;
3237
3238 i++;
3239 }
3240
3241 for (uint j = i; j < innerloop_left; j++)
3242 {
3243 device_param->combs_buf[j].i[0] = 0;
3244 device_param->combs_buf[j].i[1] = 0;
3245 device_param->combs_buf[j].i[2] = 0;
3246 device_param->combs_buf[j].i[3] = 0;
3247 device_param->combs_buf[j].i[4] = 0;
3248 device_param->combs_buf[j].i[5] = 0;
3249 device_param->combs_buf[j].i[6] = 0;
3250 device_param->combs_buf[j].i[7] = 0;
3251
3252 device_param->combs_buf[j].pw_len = 0;
3253 }
3254
3255 innerloop_left = i;
3256 }
3257 else if (data.attack_mode == ATTACK_MODE_BF)
3258 {
3259 u64 off = innerloop_pos;
3260
3261 device_param->kernel_params_mp_r_buf64[3] = off;
3262
3263 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3264 }
3265 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3266 {
3267 u64 off = innerloop_pos;
3268
3269 device_param->kernel_params_mp_buf64[3] = off;
3270
3271 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3272 }
3273 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3274 {
3275 u64 off = innerloop_pos;
3276
3277 device_param->kernel_params_mp_buf64[3] = off;
3278
3279 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3280 }
3281
3282 // copy amplifiers
3283
3284 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3285 {
3286 hc_clEnqueueCopyBuffer (data.ocl, 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);
3287 }
3288 else if (data.attack_mode == ATTACK_MODE_COMBI)
3289 {
3290 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3291 }
3292 else if (data.attack_mode == ATTACK_MODE_BF)
3293 {
3294 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3295 }
3296 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3297 {
3298 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3299 }
3300 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3301 {
3302 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3303 }
3304
3305 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3306
3307 if (data.benchmark == 1)
3308 {
3309 for (u32 i = 0; i < data.benchmark_repeats; i++)
3310 {
3311 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3312 }
3313 }
3314
3315 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3316
3317 if (data.devices_status == STATUS_CRACKED) break;
3318 if (data.devices_status == STATUS_ABORTED) break;
3319 if (data.devices_status == STATUS_QUIT) break;
3320
3321 /**
3322 * result
3323 */
3324
3325 hc_thread_mutex_lock (mux_display);
3326
3327 check_cracked (device_param, salt_pos);
3328
3329 hc_thread_mutex_unlock (mux_display);
3330
3331 /**
3332 * progress
3333 */
3334
3335 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
3336
3337 if (data.benchmark == 1)
3338 {
3339 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3340 }
3341
3342 hc_thread_mutex_lock (mux_counter);
3343
3344 data.words_progress_done[salt_pos] += perf_sum_all;
3345
3346 hc_thread_mutex_unlock (mux_counter);
3347
3348 /**
3349 * speed
3350 */
3351
3352 float speed_ms;
3353
3354 hc_timer_get (device_param->timer_speed, speed_ms);
3355
3356 hc_timer_set (&device_param->timer_speed);
3357
3358 hc_thread_mutex_lock (mux_display);
3359
3360 device_param->speed_cnt[speed_pos] = perf_sum_all;
3361
3362 device_param->speed_ms[speed_pos] = speed_ms;
3363
3364 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3365
3366 hc_thread_mutex_unlock (mux_display);
3367
3368 speed_pos++;
3369
3370 if (speed_pos == SPEED_CACHE)
3371 {
3372 speed_pos = 0;
3373 }
3374
3375 /**
3376 * benchmark
3377 */
3378
3379 if (data.benchmark == 1) break;
3380 }
3381 }
3382
3383 device_param->speed_pos = speed_pos;
3384 }
3385
3386 static void load_segment (wl_data_t *wl_data, FILE *fd)
3387 {
3388 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3389
3390 wl_data->pos = 0;
3391
3392 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3393
3394 wl_data->buf[wl_data->cnt] = 0;
3395
3396 if (wl_data->cnt == 0) return;
3397
3398 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3399
3400 while (!feof (fd))
3401 {
3402 if (wl_data->cnt == wl_data->avail)
3403 {
3404 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3405
3406 wl_data->avail += wl_data->incr;
3407 }
3408
3409 const int c = fgetc (fd);
3410
3411 if (c == EOF) break;
3412
3413 wl_data->buf[wl_data->cnt] = (char) c;
3414
3415 wl_data->cnt++;
3416
3417 if (c == '\n') break;
3418 }
3419
3420 // ensure stream ends with a newline
3421
3422 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3423 {
3424 wl_data->cnt++;
3425
3426 wl_data->buf[wl_data->cnt - 1] = '\n';
3427 }
3428
3429 return;
3430 }
3431
3432 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3433 {
3434 char *ptr = buf;
3435
3436 for (u32 i = 0; i < sz; i++, ptr++)
3437 {
3438 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3439
3440 if (i == 7)
3441 {
3442 *off = i;
3443 *len = i;
3444
3445 return;
3446 }
3447
3448 if (*ptr != '\n') continue;
3449
3450 *off = i + 1;
3451
3452 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3453
3454 *len = i;
3455
3456 return;
3457 }
3458
3459 *off = sz;
3460 *len = sz;
3461 }
3462
3463 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3464 {
3465 char *ptr = buf;
3466
3467 for (u32 i = 0; i < sz; i++, ptr++)
3468 {
3469 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3470
3471 if (*ptr != '\n') continue;
3472
3473 *off = i + 1;
3474
3475 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3476
3477 *len = i;
3478
3479 return;
3480 }
3481
3482 *off = sz;
3483 *len = sz;
3484 }
3485
3486 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3487 {
3488 char *ptr = buf;
3489
3490 for (u32 i = 0; i < sz; i++, ptr++)
3491 {
3492 if (*ptr != '\n') continue;
3493
3494 *off = i + 1;
3495
3496 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3497
3498 *len = i;
3499
3500 return;
3501 }
3502
3503 *off = sz;
3504 *len = sz;
3505 }
3506
3507 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3508 {
3509 while (wl_data->pos < wl_data->cnt)
3510 {
3511 uint off;
3512 uint len;
3513
3514 char *ptr = wl_data->buf + wl_data->pos;
3515
3516 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3517
3518 wl_data->pos += off;
3519
3520 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3521 {
3522 char rule_buf_out[BLOCK_SIZE] = { 0 };
3523
3524 int rule_len_out = -1;
3525
3526 if (len < BLOCK_SIZE)
3527 {
3528 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3529 }
3530
3531 if (rule_len_out < 0)
3532 {
3533 continue;
3534 }
3535
3536 if (rule_len_out > PW_MAX)
3537 {
3538 continue;
3539 }
3540 }
3541 else
3542 {
3543 if (len > PW_MAX)
3544 {
3545 continue;
3546 }
3547 }
3548
3549 *out_buf = ptr;
3550 *out_len = len;
3551
3552 return;
3553 }
3554
3555 if (feof (fd))
3556 {
3557 fprintf (stderr, "bug!!\n");
3558
3559 return;
3560 }
3561
3562 load_segment (wl_data, fd);
3563
3564 get_next_word (wl_data, fd, out_buf, out_len);
3565 }
3566
3567 #ifdef _POSIX
3568 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3569 #endif
3570
3571 #ifdef _WIN
3572 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3573 #endif
3574 {
3575 hc_signal (NULL);
3576
3577 dictstat_t d;
3578
3579 d.cnt = 0;
3580
3581 #ifdef _POSIX
3582 fstat (fileno (fd), &d.stat);
3583 #endif
3584
3585 #ifdef _WIN
3586 _fstat64 (fileno (fd), &d.stat);
3587 #endif
3588
3589 d.stat.st_mode = 0;
3590 d.stat.st_nlink = 0;
3591 d.stat.st_uid = 0;
3592 d.stat.st_gid = 0;
3593 d.stat.st_rdev = 0;
3594 d.stat.st_atime = 0;
3595
3596 #ifdef _POSIX
3597 d.stat.st_blksize = 0;
3598 d.stat.st_blocks = 0;
3599 #endif
3600
3601 if (d.stat.st_size == 0) return 0;
3602
3603 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3604
3605 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3606 {
3607 if (d_cache)
3608 {
3609 u64 cnt = d_cache->cnt;
3610
3611 u64 keyspace = cnt;
3612
3613 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3614 {
3615 keyspace *= data.kernel_rules_cnt;
3616 }
3617 else if (data.attack_kern == ATTACK_KERN_COMBI)
3618 {
3619 keyspace *= data.combs_cnt;
3620 }
3621
3622 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);
3623 if (data.quiet == 0) log_info ("");
3624
3625 hc_signal (sigHandler_default);
3626
3627 return (keyspace);
3628 }
3629 }
3630
3631 time_t now = 0;
3632 time_t prev = 0;
3633
3634 u64 comp = 0;
3635 u64 cnt = 0;
3636 u64 cnt2 = 0;
3637
3638 while (!feof (fd))
3639 {
3640 load_segment (wl_data, fd);
3641
3642 comp += wl_data->cnt;
3643
3644 u32 i = 0;
3645
3646 while (i < wl_data->cnt)
3647 {
3648 u32 len;
3649 u32 off;
3650
3651 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3652
3653 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3654 {
3655 char rule_buf_out[BLOCK_SIZE] = { 0 };
3656
3657 int rule_len_out = -1;
3658
3659 if (len < BLOCK_SIZE)
3660 {
3661 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3662 }
3663
3664 if (rule_len_out < 0)
3665 {
3666 len = PW_MAX1;
3667 }
3668 else
3669 {
3670 len = rule_len_out;
3671 }
3672 }
3673
3674 if (len < PW_MAX1)
3675 {
3676 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3677 {
3678 cnt += data.kernel_rules_cnt;
3679 }
3680 else if (data.attack_kern == ATTACK_KERN_COMBI)
3681 {
3682 cnt += data.combs_cnt;
3683 }
3684
3685 d.cnt++;
3686 }
3687
3688 i += off;
3689
3690 cnt2++;
3691 }
3692
3693 time (&now);
3694
3695 if ((now - prev) == 0) continue;
3696
3697 float percent = (float) comp / (float) d.stat.st_size;
3698
3699 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);
3700
3701 time (&prev);
3702 }
3703
3704 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);
3705 if (data.quiet == 0) log_info ("");
3706
3707 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3708
3709 hc_signal (sigHandler_default);
3710
3711 return (cnt);
3712 }
3713
3714 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3715 {
3716 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3717 }
3718
3719 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3720 {
3721 if (data.devices_status == STATUS_BYPASS) return 0;
3722
3723 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3724
3725 uint cache_cnt = pw_cache->cnt;
3726
3727 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3728
3729 memcpy (pw_hc1, pw_buf, pw_len);
3730
3731 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3732
3733 uint pws_cnt = device_param->pws_cnt;
3734
3735 cache_cnt++;
3736
3737 pw_t *pw = device_param->pws_buf + pws_cnt;
3738
3739 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3740
3741 pw->pw_len = pw_len;
3742
3743 pws_cnt++;
3744
3745 device_param->pws_cnt = pws_cnt;
3746 device_param->pw_cnt = pws_cnt * 1;
3747
3748 cache_cnt = 0;
3749
3750 pw_cache->cnt = cache_cnt;
3751
3752 return pws_cnt;
3753 }
3754
3755 static void *thread_monitor (void *p)
3756 {
3757 uint runtime_check = 0;
3758 uint remove_check = 0;
3759 uint status_check = 0;
3760 uint restore_check = 0;
3761
3762 uint restore_left = data.restore_timer;
3763 uint remove_left = data.remove_timer;
3764 uint status_left = data.status_timer;
3765
3766 #ifdef HAVE_HWMON
3767 uint hwmon_check = 0;
3768
3769 // these variables are mainly used for fan control (AMD only)
3770
3771 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3772
3773 // temperature controller "loopback" values
3774
3775 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3776 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3777
3778 #ifdef HAVE_ADL
3779 int temp_threshold = 1; // degrees celcius
3780
3781 int fan_speed_min = 15; // in percentage
3782 int fan_speed_max = 100;
3783 #endif // HAVE_ADL
3784
3785 time_t last_temp_check_time;
3786 #endif // HAVE_HWMON
3787
3788 uint sleep_time = 1;
3789
3790 if (data.runtime)
3791 {
3792 runtime_check = 1;
3793 }
3794
3795 if (data.restore_timer)
3796 {
3797 restore_check = 1;
3798 }
3799
3800 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3801 {
3802 remove_check = 1;
3803 }
3804
3805 if (data.status == 1)
3806 {
3807 status_check = 1;
3808 }
3809
3810 #ifdef HAVE_HWMON
3811 if (data.gpu_temp_disable == 0)
3812 {
3813 time (&last_temp_check_time);
3814
3815 hwmon_check = 1;
3816 }
3817 #endif
3818
3819 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3820 {
3821 #ifdef HAVE_HWMON
3822 if (hwmon_check == 0)
3823 #endif
3824 return (p);
3825 }
3826
3827 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3828 {
3829 hc_sleep (sleep_time);
3830
3831 if (data.devices_status != STATUS_RUNNING) continue;
3832
3833 #ifdef HAVE_HWMON
3834 if (hwmon_check == 1)
3835 {
3836 hc_thread_mutex_lock (mux_adl);
3837
3838 time_t temp_check_time;
3839
3840 time (&temp_check_time);
3841
3842 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3843
3844 if (Ta == 0) Ta = 1;
3845
3846 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3847 {
3848 hc_device_param_t *device_param = &data.devices_param[device_id];
3849
3850 if (device_param->skipped) continue;
3851
3852 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3853
3854 const int temperature = hm_get_temperature_with_device_id (device_id);
3855
3856 if (temperature > (int) data.gpu_temp_abort)
3857 {
3858 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3859
3860 if (data.devices_status != STATUS_QUIT) myabort ();
3861
3862 break;
3863 }
3864
3865 #ifdef HAVE_ADL
3866 const int gpu_temp_retain = data.gpu_temp_retain;
3867
3868 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3869 {
3870 if (data.hm_device[device_id].fan_supported == 1)
3871 {
3872 int temp_cur = temperature;
3873
3874 int temp_diff_new = gpu_temp_retain - temp_cur;
3875
3876 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3877
3878 // calculate Ta value (time difference in seconds between the last check and this check)
3879
3880 last_temp_check_time = temp_check_time;
3881
3882 float Kp = 1.8;
3883 float Ki = 0.005;
3884 float Kd = 6;
3885
3886 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3887
3888 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);
3889
3890 if (abs (fan_diff_required) >= temp_threshold)
3891 {
3892 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3893
3894 int fan_speed_level = fan_speed_cur;
3895
3896 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3897
3898 int fan_speed_new = fan_speed_level - fan_diff_required;
3899
3900 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3901 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3902
3903 if (fan_speed_new != fan_speed_cur)
3904 {
3905 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3906 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3907
3908 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3909 {
3910 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3911
3912 fan_speed_chgd[device_id] = 1;
3913 }
3914
3915 temp_diff_old[device_id] = temp_diff_new;
3916 }
3917 }
3918 }
3919 }
3920 #endif // HAVE_ADL
3921 }
3922
3923 hc_thread_mutex_unlock (mux_adl);
3924 }
3925 #endif // HAVE_HWMON
3926
3927 if (restore_check == 1)
3928 {
3929 restore_left--;
3930
3931 if (restore_left == 0)
3932 {
3933 if (data.restore_disable == 0) cycle_restore ();
3934
3935 restore_left = data.restore_timer;
3936 }
3937 }
3938
3939 if ((runtime_check == 1) && (data.runtime_start > 0))
3940 {
3941 time_t runtime_cur;
3942
3943 time (&runtime_cur);
3944
3945 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3946
3947 if (runtime_left <= 0)
3948 {
3949 if (data.benchmark == 0)
3950 {
3951 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3952 }
3953
3954 if (data.devices_status != STATUS_QUIT) myabort ();
3955 }
3956 }
3957
3958 if (remove_check == 1)
3959 {
3960 remove_left--;
3961
3962 if (remove_left == 0)
3963 {
3964 if (data.digests_saved != data.digests_done)
3965 {
3966 data.digests_saved = data.digests_done;
3967
3968 save_hash ();
3969 }
3970
3971 remove_left = data.remove_timer;
3972 }
3973 }
3974
3975 if (status_check == 1)
3976 {
3977 status_left--;
3978
3979 if (status_left == 0)
3980 {
3981 hc_thread_mutex_lock (mux_display);
3982
3983 if (data.quiet == 0) clear_prompt ();
3984
3985 if (data.quiet == 0) log_info ("");
3986
3987 status_display ();
3988
3989 if (data.quiet == 0) log_info ("");
3990
3991 hc_thread_mutex_unlock (mux_display);
3992
3993 status_left = data.status_timer;
3994 }
3995 }
3996 }
3997
3998 #ifdef HAVE_HWMON
3999 myfree (fan_speed_chgd);
4000
4001 myfree (temp_diff_old);
4002 myfree (temp_diff_sum);
4003 #endif
4004
4005 p = NULL;
4006
4007 return (p);
4008 }
4009
4010 static void *thread_outfile_remove (void *p)
4011 {
4012 // some hash-dependent constants
4013 char *outfile_dir = data.outfile_check_directory;
4014 uint dgst_size = data.dgst_size;
4015 uint isSalted = data.isSalted;
4016 uint esalt_size = data.esalt_size;
4017 uint hash_mode = data.hash_mode;
4018
4019 uint outfile_check_timer = data.outfile_check_timer;
4020
4021 char separator = data.separator;
4022
4023 // some hash-dependent functions
4024 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4025 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4026
4027 // buffers
4028 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4029
4030 hash_buf.digest = mymalloc (dgst_size);
4031
4032 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4033
4034 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4035
4036 uint digest_buf[64] = { 0 };
4037
4038 outfile_data_t *out_info = NULL;
4039
4040 char **out_files = NULL;
4041
4042 time_t folder_mtime = 0;
4043
4044 int out_cnt = 0;
4045
4046 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4047
4048 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4049 {
4050 hc_sleep (1);
4051
4052 if (data.devices_status != STATUS_RUNNING) continue;
4053
4054 check_left--;
4055
4056 if (check_left == 0)
4057 {
4058 struct stat outfile_check_stat;
4059
4060 if (stat (outfile_dir, &outfile_check_stat) == 0)
4061 {
4062 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4063
4064 if (is_dir == 1)
4065 {
4066 if (outfile_check_stat.st_mtime > folder_mtime)
4067 {
4068 char **out_files_new = scan_directory (outfile_dir);
4069
4070 int out_cnt_new = count_dictionaries (out_files_new);
4071
4072 outfile_data_t *out_info_new = NULL;
4073
4074 if (out_cnt_new > 0)
4075 {
4076 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4077
4078 for (int i = 0; i < out_cnt_new; i++)
4079 {
4080 out_info_new[i].file_name = out_files_new[i];
4081
4082 // check if there are files that we have seen/checked before (and not changed)
4083
4084 for (int j = 0; j < out_cnt; j++)
4085 {
4086 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4087 {
4088 struct stat outfile_stat;
4089
4090 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4091 {
4092 if (outfile_stat.st_ctime == out_info[j].ctime)
4093 {
4094 out_info_new[i].ctime = out_info[j].ctime;
4095 out_info_new[i].seek = out_info[j].seek;
4096 }
4097 }
4098 }
4099 }
4100 }
4101 }
4102
4103 local_free (out_info);
4104 local_free (out_files);
4105
4106 out_files = out_files_new;
4107 out_cnt = out_cnt_new;
4108 out_info = out_info_new;
4109
4110 folder_mtime = outfile_check_stat.st_mtime;
4111 }
4112
4113 for (int j = 0; j < out_cnt; j++)
4114 {
4115 FILE *fp = fopen (out_info[j].file_name, "rb");
4116
4117 if (fp != NULL)
4118 {
4119 //hc_thread_mutex_lock (mux_display);
4120
4121 #ifdef _POSIX
4122 struct stat outfile_stat;
4123
4124 fstat (fileno (fp), &outfile_stat);
4125 #endif
4126
4127 #ifdef _WIN
4128 struct stat64 outfile_stat;
4129
4130 _fstat64 (fileno (fp), &outfile_stat);
4131 #endif
4132
4133 if (outfile_stat.st_ctime > out_info[j].ctime)
4134 {
4135 out_info[j].ctime = outfile_stat.st_ctime;
4136 out_info[j].seek = 0;
4137 }
4138
4139 fseek (fp, out_info[j].seek, SEEK_SET);
4140
4141 while (!feof (fp))
4142 {
4143 char line_buf[BUFSIZ] = { 0 };
4144
4145 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
4146
4147 if (ptr == NULL) break;
4148
4149 int line_len = strlen (line_buf);
4150
4151 if (line_len <= 0) continue;
4152
4153 int iter = MAX_CUT_TRIES;
4154
4155 for (uint i = line_len - 1; i && iter; i--, line_len--)
4156 {
4157 if (line_buf[i] != separator) continue;
4158
4159 int parser_status = PARSER_OK;
4160
4161 if ((hash_mode != 2500) && (hash_mode != 6800))
4162 {
4163 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4164 }
4165
4166 uint found = 0;
4167
4168 if (parser_status == PARSER_OK)
4169 {
4170 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4171 {
4172 if (data.salts_shown[salt_pos] == 1) continue;
4173
4174 salt_t *salt_buf = &data.salts_buf[salt_pos];
4175
4176 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4177 {
4178 uint idx = salt_buf->digests_offset + digest_pos;
4179
4180 if (data.digests_shown[idx] == 1) continue;
4181
4182 uint cracked = 0;
4183
4184 if (hash_mode == 6800)
4185 {
4186 if (i == salt_buf->salt_len)
4187 {
4188 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4189 }
4190 }
4191 else if (hash_mode == 2500)
4192 {
4193 // BSSID : MAC1 : MAC2 (:plain)
4194 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4195 {
4196 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4197
4198 if (!cracked) continue;
4199
4200 // now compare MAC1 and MAC2 too, since we have this additional info
4201 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4202 char *mac2_pos = mac1_pos + 12 + 1;
4203
4204 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4205 wpa_t *wpa = &wpas[salt_pos];
4206
4207 uint pke[25] = { 0 };
4208
4209 char *pke_ptr = (char *) pke;
4210
4211 for (uint i = 0; i < 25; i++)
4212 {
4213 pke[i] = byte_swap_32 (wpa->pke[i]);
4214 }
4215
4216 u8 mac1[6] = { 0 };
4217 u8 mac2[6] = { 0 };
4218
4219 memcpy (mac1, pke_ptr + 23, 6);
4220 memcpy (mac2, pke_ptr + 29, 6);
4221
4222 // compare hex string(s) vs binary MAC address(es)
4223
4224 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4225 {
4226 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4227 {
4228 cracked = 0;
4229 break;
4230 }
4231 }
4232
4233 // early skip ;)
4234 if (!cracked) continue;
4235
4236 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4237 {
4238 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4239 {
4240 cracked = 0;
4241 break;
4242 }
4243 }
4244 }
4245 }
4246 else
4247 {
4248 char *digests_buf_ptr = (char *) data.digests_buf;
4249
4250 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4251
4252 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4253 }
4254
4255 if (cracked == 1)
4256 {
4257 found = 1;
4258
4259 data.digests_shown[idx] = 1;
4260
4261 data.digests_done++;
4262
4263 salt_buf->digests_done++;
4264
4265 if (salt_buf->digests_done == salt_buf->digests_cnt)
4266 {
4267 data.salts_shown[salt_pos] = 1;
4268
4269 data.salts_done++;
4270
4271 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4272 }
4273 }
4274 }
4275
4276 if (data.devices_status == STATUS_CRACKED) break;
4277 }
4278 }
4279
4280 if (found) break;
4281
4282 if (data.devices_status == STATUS_CRACKED) break;
4283
4284 iter--;
4285 }
4286
4287 if (data.devices_status == STATUS_CRACKED) break;
4288 }
4289
4290 out_info[j].seek = ftell (fp);
4291
4292 //hc_thread_mutex_unlock (mux_display);
4293
4294 fclose (fp);
4295 }
4296 }
4297 }
4298 }
4299
4300 check_left = outfile_check_timer;
4301 }
4302 }
4303
4304 if (esalt_size) local_free (hash_buf.esalt);
4305
4306 if (isSalted) local_free (hash_buf.salt);
4307
4308 local_free (hash_buf.digest);
4309
4310 local_free (out_info);
4311
4312 local_free (out_files);
4313
4314 p = NULL;
4315
4316 return (p);
4317 }
4318
4319 static uint get_work (hc_device_param_t *device_param, const u64 max)
4320 {
4321 hc_thread_mutex_lock (mux_dispatcher);
4322
4323 const u64 words_cur = data.words_cur;
4324 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4325
4326 device_param->words_off = words_cur;
4327
4328 const u64 words_left = words_base - words_cur;
4329
4330 if (data.kernel_power_all > words_left)
4331 {
4332 if (data.kernel_power_div == 0)
4333 {
4334 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4335 }
4336 }
4337
4338 if (data.kernel_power_div)
4339 {
4340 if (device_param->kernel_power == device_param->kernel_power_user)
4341 {
4342 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4343
4344 if (kernel_power_new < device_param->kernel_power)
4345 {
4346 device_param->kernel_power = kernel_power_new;
4347 }
4348 }
4349 }
4350
4351 const uint kernel_power = device_param->kernel_power;
4352
4353 uint work = MIN (words_left, kernel_power);
4354
4355 work = MIN (work, max);
4356
4357 data.words_cur += work;
4358
4359 hc_thread_mutex_unlock (mux_dispatcher);
4360
4361 return work;
4362 }
4363
4364 static void *thread_calc_stdin (void *p)
4365 {
4366 hc_device_param_t *device_param = (hc_device_param_t *) p;
4367
4368 if (device_param->skipped) return NULL;
4369
4370 autotune (device_param);
4371
4372 const uint attack_kern = data.attack_kern;
4373
4374 const uint kernel_power = device_param->kernel_power;
4375
4376 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4377 {
4378 hc_thread_mutex_lock (mux_dispatcher);
4379
4380 if (feof (stdin) != 0)
4381 {
4382 hc_thread_mutex_unlock (mux_dispatcher);
4383
4384 break;
4385 }
4386
4387 uint words_cur = 0;
4388
4389 while (words_cur < kernel_power)
4390 {
4391 char buf[BUFSIZ] = { 0 };
4392
4393 char *line_buf = fgets (buf, sizeof (buf), stdin);
4394
4395 if (line_buf == NULL) break;
4396
4397 uint line_len = in_superchop (line_buf);
4398
4399 line_len = convert_from_hex (line_buf, line_len);
4400
4401 // post-process rule engine
4402
4403 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4404 {
4405 char rule_buf_out[BLOCK_SIZE] = { 0 };
4406
4407 int rule_len_out = -1;
4408
4409 if (line_len < BLOCK_SIZE)
4410 {
4411 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4412 }
4413
4414 if (rule_len_out < 0) continue;
4415
4416 line_buf = rule_buf_out;
4417 line_len = rule_len_out;
4418 }
4419
4420 if (line_len > PW_MAX)
4421 {
4422 continue;
4423 }
4424
4425 if (attack_kern == ATTACK_KERN_STRAIGHT)
4426 {
4427 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4428 {
4429 hc_thread_mutex_lock (mux_counter);
4430
4431 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4432 {
4433 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4434 }
4435
4436 hc_thread_mutex_unlock (mux_counter);
4437
4438 continue;
4439 }
4440 }
4441 else if (attack_kern == ATTACK_KERN_COMBI)
4442 {
4443 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4444 // since we still need to combine the plains
4445
4446 if (line_len > data.pw_max)
4447 {
4448 hc_thread_mutex_lock (mux_counter);
4449
4450 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4451 {
4452 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4453 }
4454
4455 hc_thread_mutex_unlock (mux_counter);
4456
4457 continue;
4458 }
4459 }
4460
4461 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4462
4463 words_cur++;
4464
4465 if (data.devices_status == STATUS_CRACKED) break;
4466 if (data.devices_status == STATUS_ABORTED) break;
4467 if (data.devices_status == STATUS_QUIT) break;
4468 if (data.devices_status == STATUS_BYPASS) break;
4469 }
4470
4471 hc_thread_mutex_unlock (mux_dispatcher);
4472
4473 if (data.devices_status == STATUS_CRACKED) break;
4474 if (data.devices_status == STATUS_ABORTED) break;
4475 if (data.devices_status == STATUS_QUIT) break;
4476 if (data.devices_status == STATUS_BYPASS) break;
4477
4478 // we need 2 flushing because we have two independant caches and it can occur
4479 // that one buffer is already at threshold plus for that length also exists
4480 // more data in the 2nd buffer so it would overflow
4481
4482 // flush session 1
4483
4484 {
4485 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4486 {
4487 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4488
4489 const uint pw_cache_cnt = pw_cache->cnt;
4490
4491 if (pw_cache_cnt == 0) continue;
4492
4493 pw_cache->cnt = 0;
4494
4495 uint pws_cnt = device_param->pws_cnt;
4496
4497 pw_t *pw = device_param->pws_buf + pws_cnt;
4498
4499 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4500
4501 pw->pw_len = pw_len;
4502
4503 uint pw_cnt = device_param->pw_cnt;
4504
4505 pw_cnt += pw_cache_cnt;
4506
4507 device_param->pw_cnt = pw_cnt;
4508
4509 pws_cnt++;
4510
4511 device_param->pws_cnt = pws_cnt;
4512
4513 if (pws_cnt == device_param->kernel_power_user) break;
4514 }
4515
4516 const uint pw_cnt = device_param->pw_cnt;
4517 const uint pws_cnt = device_param->pws_cnt;
4518
4519 if (pws_cnt)
4520 {
4521 run_copy (device_param, pws_cnt);
4522
4523 run_cracker (device_param, pw_cnt, pws_cnt);
4524
4525 device_param->pw_cnt = 0;
4526 device_param->pws_cnt = 0;
4527 }
4528 }
4529
4530 // flush session 2
4531
4532 {
4533 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4534 {
4535 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4536
4537 const uint pw_cache_cnt = pw_cache->cnt;
4538
4539 if (pw_cache_cnt == 0) continue;
4540
4541 pw_cache->cnt = 0;
4542
4543 uint pws_cnt = device_param->pws_cnt;
4544
4545 pw_t *pw = device_param->pws_buf + pws_cnt;
4546
4547 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4548
4549 pw->pw_len = pw_len;
4550
4551 uint pw_cnt = device_param->pw_cnt;
4552
4553 pw_cnt += pw_cache_cnt;
4554
4555 device_param->pw_cnt = pw_cnt;
4556
4557 pws_cnt++;
4558
4559 device_param->pws_cnt = pws_cnt;
4560 }
4561
4562 const uint pw_cnt = device_param->pw_cnt;
4563 const uint pws_cnt = device_param->pws_cnt;
4564
4565 if (pws_cnt)
4566 {
4567 run_copy (device_param, pws_cnt);
4568
4569 run_cracker (device_param, pw_cnt, pws_cnt);
4570
4571 device_param->pw_cnt = 0;
4572 device_param->pws_cnt = 0;
4573 }
4574 }
4575 }
4576
4577 device_param->kernel_accel = 0;
4578 device_param->kernel_loops = 0;
4579
4580 return NULL;
4581 }
4582
4583 static void *thread_calc (void *p)
4584 {
4585 hc_device_param_t *device_param = (hc_device_param_t *) p;
4586
4587 if (device_param->skipped) return NULL;
4588
4589 autotune (device_param);
4590
4591 const uint attack_mode = data.attack_mode;
4592 const uint attack_kern = data.attack_kern;
4593
4594 if (attack_mode == ATTACK_MODE_BF)
4595 {
4596 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4597 {
4598 const uint work = get_work (device_param, -1);
4599
4600 if (work == 0) break;
4601
4602 const u64 words_off = device_param->words_off;
4603 const u64 words_fin = words_off + work;
4604
4605 const uint pw_cnt = work;
4606 const uint pws_cnt = work;
4607
4608 device_param->pw_cnt = pw_cnt;
4609 device_param->pws_cnt = pws_cnt;
4610
4611 if (pws_cnt)
4612 {
4613 run_copy (device_param, pws_cnt);
4614
4615 run_cracker (device_param, pw_cnt, pws_cnt);
4616
4617 device_param->pw_cnt = 0;
4618 device_param->pws_cnt = 0;
4619 }
4620
4621 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4622
4623 if (data.devices_status == STATUS_CRACKED) break;
4624 if (data.devices_status == STATUS_ABORTED) break;
4625 if (data.devices_status == STATUS_QUIT) break;
4626 if (data.devices_status == STATUS_BYPASS) break;
4627
4628 if (data.benchmark == 1) break;
4629
4630 device_param->words_done = words_fin;
4631 }
4632 }
4633 else
4634 {
4635 const uint segment_size = data.segment_size;
4636
4637 char *dictfile = data.dictfile;
4638
4639 if (attack_mode == ATTACK_MODE_COMBI)
4640 {
4641 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4642 {
4643 dictfile = data.dictfile2;
4644 }
4645 }
4646
4647 FILE *fd = fopen (dictfile, "rb");
4648
4649 if (fd == NULL)
4650 {
4651 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4652
4653 return NULL;
4654 }
4655
4656 if (attack_mode == ATTACK_MODE_COMBI)
4657 {
4658 const uint combs_mode = data.combs_mode;
4659
4660 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4661 {
4662 const char *dictfilec = data.dictfile2;
4663
4664 FILE *combs_fp = fopen (dictfilec, "rb");
4665
4666 if (combs_fp == NULL)
4667 {
4668 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4669
4670 fclose (fd);
4671
4672 return NULL;
4673 }
4674
4675 device_param->combs_fp = combs_fp;
4676 }
4677 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4678 {
4679 const char *dictfilec = data.dictfile;
4680
4681 FILE *combs_fp = fopen (dictfilec, "rb");
4682
4683 if (combs_fp == NULL)
4684 {
4685 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4686
4687 fclose (fd);
4688
4689 return NULL;
4690 }
4691
4692 device_param->combs_fp = combs_fp;
4693 }
4694 }
4695
4696 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4697
4698 wl_data->buf = (char *) mymalloc (segment_size);
4699 wl_data->avail = segment_size;
4700 wl_data->incr = segment_size;
4701 wl_data->cnt = 0;
4702 wl_data->pos = 0;
4703
4704 u64 words_cur = 0;
4705
4706 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4707 {
4708 u64 words_off = 0;
4709 u64 words_fin = 0;
4710
4711 u64 max = -1;
4712
4713 while (max)
4714 {
4715 const uint work = get_work (device_param, max);
4716
4717 if (work == 0) break;
4718
4719 words_off = device_param->words_off;
4720 words_fin = words_off + work;
4721
4722 char *line_buf;
4723 uint line_len;
4724
4725 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4726
4727 max = 0;
4728
4729 for ( ; words_cur < words_fin; words_cur++)
4730 {
4731 get_next_word (wl_data, fd, &line_buf, &line_len);
4732
4733 line_len = convert_from_hex (line_buf, line_len);
4734
4735 // post-process rule engine
4736
4737 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4738 {
4739 char rule_buf_out[BLOCK_SIZE] = { 0 };
4740
4741 int rule_len_out = -1;
4742
4743 if (line_len < BLOCK_SIZE)
4744 {
4745 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4746 }
4747
4748 if (rule_len_out < 0) continue;
4749
4750 line_buf = rule_buf_out;
4751 line_len = rule_len_out;
4752 }
4753
4754 if (attack_kern == ATTACK_KERN_STRAIGHT)
4755 {
4756 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4757 {
4758 max++;
4759
4760 hc_thread_mutex_lock (mux_counter);
4761
4762 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4763 {
4764 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4765 }
4766
4767 hc_thread_mutex_unlock (mux_counter);
4768
4769 continue;
4770 }
4771 }
4772 else if (attack_kern == ATTACK_KERN_COMBI)
4773 {
4774 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4775 // since we still need to combine the plains
4776
4777 if (line_len > data.pw_max)
4778 {
4779 max++;
4780
4781 hc_thread_mutex_lock (mux_counter);
4782
4783 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4784 {
4785 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4786 }
4787
4788 hc_thread_mutex_unlock (mux_counter);
4789
4790 continue;
4791 }
4792 }
4793
4794 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4795
4796 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4797
4798 if (data.devices_status == STATUS_CRACKED) break;
4799 if (data.devices_status == STATUS_ABORTED) break;
4800 if (data.devices_status == STATUS_QUIT) break;
4801 if (data.devices_status == STATUS_BYPASS) break;
4802 }
4803
4804 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4805
4806 if (data.devices_status == STATUS_CRACKED) break;
4807 if (data.devices_status == STATUS_ABORTED) break;
4808 if (data.devices_status == STATUS_QUIT) break;
4809 if (data.devices_status == STATUS_BYPASS) break;
4810 }
4811
4812 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4813
4814 if (data.devices_status == STATUS_CRACKED) break;
4815 if (data.devices_status == STATUS_ABORTED) break;
4816 if (data.devices_status == STATUS_QUIT) break;
4817 if (data.devices_status == STATUS_BYPASS) break;
4818
4819 // we need 2 flushing because we have two independant caches and it can occur
4820 // that one buffer is already at threshold plus for that length also exists
4821 // more data in the 2nd buffer so it would overflow
4822
4823 //
4824 // flush session 1
4825 //
4826
4827 {
4828 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4829 {
4830 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4831
4832 const uint pw_cache_cnt = pw_cache->cnt;
4833
4834 if (pw_cache_cnt == 0) continue;
4835
4836 pw_cache->cnt = 0;
4837
4838 uint pws_cnt = device_param->pws_cnt;
4839
4840 pw_t *pw = device_param->pws_buf + pws_cnt;
4841
4842 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4843
4844 pw->pw_len = pw_len;
4845
4846 uint pw_cnt = device_param->pw_cnt;
4847
4848 pw_cnt += pw_cache_cnt;
4849
4850 device_param->pw_cnt = pw_cnt;
4851
4852 pws_cnt++;
4853
4854 device_param->pws_cnt = pws_cnt;
4855
4856 if (pws_cnt == device_param->kernel_power_user) break;
4857 }
4858
4859 const uint pw_cnt = device_param->pw_cnt;
4860 const uint pws_cnt = device_param->pws_cnt;
4861
4862 if (pws_cnt)
4863 {
4864 run_copy (device_param, pws_cnt);
4865
4866 run_cracker (device_param, pw_cnt, pws_cnt);
4867
4868 device_param->pw_cnt = 0;
4869 device_param->pws_cnt = 0;
4870 }
4871
4872 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4873
4874 if (data.devices_status == STATUS_CRACKED) break;
4875 if (data.devices_status == STATUS_ABORTED) break;
4876 if (data.devices_status == STATUS_QUIT) break;
4877 if (data.devices_status == STATUS_BYPASS) break;
4878 }
4879
4880 //
4881 // flush session 2
4882 //
4883
4884 {
4885 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4886 {
4887 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4888
4889 const uint pw_cache_cnt = pw_cache->cnt;
4890
4891 if (pw_cache_cnt == 0) continue;
4892
4893 pw_cache->cnt = 0;
4894
4895 uint pws_cnt = device_param->pws_cnt;
4896
4897 pw_t *pw = device_param->pws_buf + pws_cnt;
4898
4899 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4900
4901 pw->pw_len = pw_len;
4902
4903 uint pw_cnt = device_param->pw_cnt;
4904
4905 pw_cnt += pw_cache_cnt;
4906
4907 device_param->pw_cnt = pw_cnt;
4908
4909 pws_cnt++;
4910
4911 device_param->pws_cnt = pws_cnt;
4912 }
4913
4914 const uint pw_cnt = device_param->pw_cnt;
4915 const uint pws_cnt = device_param->pws_cnt;
4916
4917 if (pws_cnt)
4918 {
4919 run_copy (device_param, pws_cnt);
4920
4921 run_cracker (device_param, pw_cnt, pws_cnt);
4922
4923 device_param->pw_cnt = 0;
4924 device_param->pws_cnt = 0;
4925 }
4926
4927 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4928
4929 if (data.devices_status == STATUS_CRACKED) break;
4930 if (data.devices_status == STATUS_ABORTED) break;
4931 if (data.devices_status == STATUS_QUIT) break;
4932 if (data.devices_status == STATUS_BYPASS) break;
4933 }
4934
4935 if (words_fin == 0) break;
4936
4937 device_param->words_done = words_fin;
4938 }
4939
4940 if (attack_mode == ATTACK_MODE_COMBI)
4941 {
4942 fclose (device_param->combs_fp);
4943 }
4944
4945 free (wl_data->buf);
4946 free (wl_data);
4947
4948 fclose (fd);
4949 }
4950
4951 device_param->kernel_accel = 0;
4952 device_param->kernel_loops = 0;
4953
4954 return NULL;
4955 }
4956
4957 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4958 {
4959 if (!device_param)
4960 {
4961 log_error ("ERROR: %s : Invalid argument", __func__);
4962
4963 exit (-1);
4964 }
4965
4966 salt_t *salt_buf = &data.salts_buf[salt_pos];
4967
4968 device_param->kernel_params_buf32[24] = salt_pos;
4969 device_param->kernel_params_buf32[27] = 1;
4970 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4971 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4972 device_param->kernel_params_buf32[30] = 0;
4973 device_param->kernel_params_buf32[31] = 1;
4974
4975 char *dictfile_old = data.dictfile;
4976
4977 const char *weak_hash_check = "weak-hash-check";
4978
4979 data.dictfile = (char *) weak_hash_check;
4980
4981 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4982
4983 data.kernel_rules_buf[0].cmds[0] = 0;
4984
4985 /**
4986 * run the kernel
4987 */
4988
4989 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4990 {
4991 run_kernel (KERN_RUN_1, device_param, 1, false);
4992 }
4993 else
4994 {
4995 run_kernel (KERN_RUN_1, device_param, 1, false);
4996
4997 uint loop_step = 16;
4998
4999 const uint iter = salt_buf->salt_iter;
5000
5001 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5002 {
5003 uint loop_left = iter - loop_pos;
5004
5005 loop_left = MIN (loop_left, loop_step);
5006
5007 device_param->kernel_params_buf32[25] = loop_pos;
5008 device_param->kernel_params_buf32[26] = loop_left;
5009
5010 run_kernel (KERN_RUN_2, device_param, 1, false);
5011 }
5012
5013 run_kernel (KERN_RUN_3, device_param, 1, false);
5014 }
5015
5016 /**
5017 * result
5018 */
5019
5020 check_cracked (device_param, salt_pos);
5021
5022 /**
5023 * cleanup
5024 */
5025
5026 device_param->kernel_params_buf32[24] = 0;
5027 device_param->kernel_params_buf32[25] = 0;
5028 device_param->kernel_params_buf32[26] = 0;
5029 device_param->kernel_params_buf32[27] = 0;
5030 device_param->kernel_params_buf32[28] = 0;
5031 device_param->kernel_params_buf32[29] = 0;
5032 device_param->kernel_params_buf32[30] = 0;
5033 device_param->kernel_params_buf32[31] = 0;
5034
5035 data.dictfile = dictfile_old;
5036
5037 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5038 }
5039
5040 // hlfmt hashcat
5041
5042 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5043 {
5044 if (data.username == 0)
5045 {
5046 *hashbuf_pos = line_buf;
5047 *hashbuf_len = line_len;
5048 }
5049 else
5050 {
5051 char *pos = line_buf;
5052 int len = line_len;
5053
5054 for (int i = 0; i < line_len; i++, pos++, len--)
5055 {
5056 if (line_buf[i] == data.separator)
5057 {
5058 pos++;
5059
5060 len--;
5061
5062 break;
5063 }
5064 }
5065
5066 *hashbuf_pos = pos;
5067 *hashbuf_len = len;
5068 }
5069 }
5070
5071 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5072 {
5073 char *pos = NULL;
5074 int len = 0;
5075
5076 int sep_cnt = 0;
5077
5078 for (int i = 0; i < line_len; i++)
5079 {
5080 if (line_buf[i] == data.separator)
5081 {
5082 sep_cnt++;
5083
5084 continue;
5085 }
5086
5087 if (sep_cnt == 0)
5088 {
5089 if (pos == NULL) pos = line_buf + i;
5090
5091 len++;
5092 }
5093 }
5094
5095 *userbuf_pos = pos;
5096 *userbuf_len = len;
5097 }
5098
5099 // hlfmt pwdump
5100
5101 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
5102 {
5103 int sep_cnt = 0;
5104
5105 int sep2_len = 0;
5106 int sep3_len = 0;
5107
5108 for (int i = 0; i < line_len; i++)
5109 {
5110 if (line_buf[i] == ':')
5111 {
5112 sep_cnt++;
5113
5114 continue;
5115 }
5116
5117 if (sep_cnt == 2) sep2_len++;
5118 if (sep_cnt == 3) sep3_len++;
5119 }
5120
5121 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5122
5123 return 0;
5124 }
5125
5126 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5127 {
5128 char *pos = NULL;
5129 int len = 0;
5130
5131 int sep_cnt = 0;
5132
5133 for (int i = 0; i < line_len; i++)
5134 {
5135 if (line_buf[i] == ':')
5136 {
5137 sep_cnt++;
5138
5139 continue;
5140 }
5141
5142 if (data.hash_mode == 1000)
5143 {
5144 if (sep_cnt == 3)
5145 {
5146 if (pos == NULL) pos = line_buf + i;
5147
5148 len++;
5149 }
5150 }
5151 else if (data.hash_mode == 3000)
5152 {
5153 if (sep_cnt == 2)
5154 {
5155 if (pos == NULL) pos = line_buf + i;
5156
5157 len++;
5158 }
5159 }
5160 }
5161
5162 *hashbuf_pos = pos;
5163 *hashbuf_len = len;
5164 }
5165
5166 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5167 {
5168 char *pos = NULL;
5169 int len = 0;
5170
5171 int sep_cnt = 0;
5172
5173 for (int i = 0; i < line_len; i++)
5174 {
5175 if (line_buf[i] == ':')
5176 {
5177 sep_cnt++;
5178
5179 continue;
5180 }
5181
5182 if (sep_cnt == 0)
5183 {
5184 if (pos == NULL) pos = line_buf + i;
5185
5186 len++;
5187 }
5188 }
5189
5190 *userbuf_pos = pos;
5191 *userbuf_len = len;
5192 }
5193
5194 // hlfmt passwd
5195
5196 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5197 {
5198 int sep_cnt = 0;
5199
5200 char sep5_first = 0;
5201 char sep6_first = 0;
5202
5203 for (int i = 0; i < line_len; i++)
5204 {
5205 if (line_buf[i] == ':')
5206 {
5207 sep_cnt++;
5208
5209 continue;
5210 }
5211
5212 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5213 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5214 }
5215
5216 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5217
5218 return 0;
5219 }
5220
5221 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5222 {
5223 char *pos = NULL;
5224 int len = 0;
5225
5226 int sep_cnt = 0;
5227
5228 for (int i = 0; i < line_len; i++)
5229 {
5230 if (line_buf[i] == ':')
5231 {
5232 sep_cnt++;
5233
5234 continue;
5235 }
5236
5237 if (sep_cnt == 1)
5238 {
5239 if (pos == NULL) pos = line_buf + i;
5240
5241 len++;
5242 }
5243 }
5244
5245 *hashbuf_pos = pos;
5246 *hashbuf_len = len;
5247 }
5248
5249 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5250 {
5251 char *pos = NULL;
5252 int len = 0;
5253
5254 int sep_cnt = 0;
5255
5256 for (int i = 0; i < line_len; i++)
5257 {
5258 if (line_buf[i] == ':')
5259 {
5260 sep_cnt++;
5261
5262 continue;
5263 }
5264
5265 if (sep_cnt == 0)
5266 {
5267 if (pos == NULL) pos = line_buf + i;
5268
5269 len++;
5270 }
5271 }
5272
5273 *userbuf_pos = pos;
5274 *userbuf_len = len;
5275 }
5276
5277 // hlfmt shadow
5278
5279 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5280 {
5281 int sep_cnt = 0;
5282
5283 for (int i = 0; i < line_len; i++)
5284 {
5285 if (line_buf[i] == ':') sep_cnt++;
5286 }
5287
5288 if (sep_cnt == 8) return 1;
5289
5290 return 0;
5291 }
5292
5293 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5294 {
5295 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5296 }
5297
5298 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5299 {
5300 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5301 }
5302
5303 // hlfmt main
5304
5305 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5306 {
5307 switch (hashfile_format)
5308 {
5309 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5310 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5311 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5312 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5313 }
5314 }
5315
5316 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5317 {
5318 switch (hashfile_format)
5319 {
5320 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5321 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5322 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5323 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5324 }
5325 }
5326
5327 static uint hlfmt_detect (FILE *fp, uint max_check)
5328 {
5329 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5330
5331 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5332 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5333
5334 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5335
5336 uint num_check = 0;
5337
5338 while (!feof (fp))
5339 {
5340 char line_buf[BUFSIZ] = { 0 };
5341
5342 int line_len = fgetl (fp, line_buf);
5343
5344 if (line_len == 0) continue;
5345
5346 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5347 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5348 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5349
5350 if (num_check == max_check) break;
5351
5352 num_check++;
5353 }
5354
5355 uint hashlist_format = HLFMT_HASHCAT;
5356
5357 for (int i = 1; i < HLFMTS_CNT; i++)
5358 {
5359 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5360
5361 hashlist_format = i;
5362 }
5363
5364 free (formats_cnt);
5365
5366 return hashlist_format;
5367 }
5368
5369 /**
5370 * some further helper function
5371 */
5372
5373 // wrapper around mymalloc for ADL
5374
5375 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5376 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5377 {
5378 return mymalloc (iSize);
5379 }
5380 #endif
5381
5382 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)
5383 {
5384 u64 collisions = 0;
5385
5386 const uint dgst_pos0 = data.dgst_pos0;
5387 const uint dgst_pos1 = data.dgst_pos1;
5388 const uint dgst_pos2 = data.dgst_pos2;
5389 const uint dgst_pos3 = data.dgst_pos3;
5390
5391 memset (bitmap_a, 0, bitmap_size);
5392 memset (bitmap_b, 0, bitmap_size);
5393 memset (bitmap_c, 0, bitmap_size);
5394 memset (bitmap_d, 0, bitmap_size);
5395
5396 for (uint i = 0; i < digests_cnt; i++)
5397 {
5398 uint *digest_ptr = (uint *) digests_buf_ptr;
5399
5400 digests_buf_ptr += dgst_size;
5401
5402 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5403 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5404 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5405 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5406
5407 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5408 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5409 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5410 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5411
5412 if (bitmap_a[idx0] & val0) collisions++;
5413 if (bitmap_b[idx1] & val1) collisions++;
5414 if (bitmap_c[idx2] & val2) collisions++;
5415 if (bitmap_d[idx3] & val3) collisions++;
5416
5417 bitmap_a[idx0] |= val0;
5418 bitmap_b[idx1] |= val1;
5419 bitmap_c[idx2] |= val2;
5420 bitmap_d[idx3] |= val3;
5421
5422 if (collisions >= collisions_max) return 0x7fffffff;
5423 }
5424
5425 return collisions;
5426 }
5427
5428 /**
5429 * main
5430 */
5431
5432 int main (int argc, char **argv)
5433 {
5434 /**
5435 * To help users a bit
5436 */
5437
5438 char *compute = getenv ("COMPUTE");
5439
5440 if (compute)
5441 {
5442 static char display[100];
5443
5444 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5445
5446 putenv (display);
5447 }
5448 else
5449 {
5450 if (getenv ("DISPLAY") == NULL)
5451 putenv ((char *) "DISPLAY=:0");
5452 }
5453
5454 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5455 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5456
5457 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5458 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5459
5460 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5461 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5462
5463 /**
5464 * Real init
5465 */
5466
5467 memset (&data, 0, sizeof (hc_global_data_t));
5468
5469 time_t proc_start;
5470
5471 time (&proc_start);
5472
5473 data.proc_start = proc_start;
5474
5475 int myargc = argc;
5476 char **myargv = argv;
5477
5478 hc_thread_mutex_init (mux_dispatcher);
5479 hc_thread_mutex_init (mux_counter);
5480 hc_thread_mutex_init (mux_display);
5481 hc_thread_mutex_init (mux_adl);
5482
5483 /**
5484 * commandline parameters
5485 */
5486
5487 uint usage = USAGE;
5488 uint version = VERSION;
5489 uint quiet = QUIET;
5490 uint benchmark = BENCHMARK;
5491 uint benchmark_repeats = BENCHMARK_REPEATS;
5492 uint show = SHOW;
5493 uint left = LEFT;
5494 uint username = USERNAME;
5495 uint remove = REMOVE;
5496 uint remove_timer = REMOVE_TIMER;
5497 u64 skip = SKIP;
5498 u64 limit = LIMIT;
5499 uint keyspace = KEYSPACE;
5500 uint potfile_disable = POTFILE_DISABLE;
5501 uint debug_mode = DEBUG_MODE;
5502 char *debug_file = NULL;
5503 char *induction_dir = NULL;
5504 char *outfile_check_dir = NULL;
5505 uint force = FORCE;
5506 uint runtime = RUNTIME;
5507 uint hash_mode = HASH_MODE;
5508 uint attack_mode = ATTACK_MODE;
5509 uint markov_disable = MARKOV_DISABLE;
5510 uint markov_classic = MARKOV_CLASSIC;
5511 uint markov_threshold = MARKOV_THRESHOLD;
5512 char *markov_hcstat = NULL;
5513 char *outfile = NULL;
5514 uint outfile_format = OUTFILE_FORMAT;
5515 uint outfile_autohex = OUTFILE_AUTOHEX;
5516 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5517 uint restore = RESTORE;
5518 uint restore_timer = RESTORE_TIMER;
5519 uint restore_disable = RESTORE_DISABLE;
5520 uint status = STATUS;
5521 uint status_timer = STATUS_TIMER;
5522 uint status_automat = STATUS_AUTOMAT;
5523 uint loopback = LOOPBACK;
5524 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5525 char *session = NULL;
5526 uint hex_charset = HEX_CHARSET;
5527 uint hex_salt = HEX_SALT;
5528 uint hex_wordlist = HEX_WORDLIST;
5529 uint rp_gen = RP_GEN;
5530 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5531 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5532 uint rp_gen_seed = RP_GEN_SEED;
5533 char *rule_buf_l = (char *) RULE_BUF_L;
5534 char *rule_buf_r = (char *) RULE_BUF_R;
5535 uint increment = INCREMENT;
5536 uint increment_min = INCREMENT_MIN;
5537 uint increment_max = INCREMENT_MAX;
5538 char *cpu_affinity = NULL;
5539 OCL_PTR *ocl = NULL;
5540 char *opencl_devices = NULL;
5541 char *opencl_platforms = NULL;
5542 char *opencl_device_types = NULL;
5543 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5544 char *truecrypt_keyfiles = NULL;
5545 uint workload_profile = WORKLOAD_PROFILE;
5546 uint kernel_accel = KERNEL_ACCEL;
5547 uint kernel_loops = KERNEL_LOOPS;
5548 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5549 #ifdef HAVE_HWMON
5550 uint gpu_temp_abort = GPU_TEMP_ABORT;
5551 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5552 #ifdef HAVE_ADL
5553 uint powertune_enable = POWERTUNE_ENABLE;
5554 #endif
5555 #endif
5556 uint logfile_disable = LOGFILE_DISABLE;
5557 uint segment_size = SEGMENT_SIZE;
5558 uint scrypt_tmto = SCRYPT_TMTO;
5559 char separator = SEPARATOR;
5560 uint bitmap_min = BITMAP_MIN;
5561 uint bitmap_max = BITMAP_MAX;
5562 char *custom_charset_1 = NULL;
5563 char *custom_charset_2 = NULL;
5564 char *custom_charset_3 = NULL;
5565 char *custom_charset_4 = NULL;
5566
5567 #define IDX_HELP 'h'
5568 #define IDX_VERSION 'V'
5569 #define IDX_VERSION_LOWER 'v'
5570 #define IDX_QUIET 0xff02
5571 #define IDX_SHOW 0xff03
5572 #define IDX_LEFT 0xff04
5573 #define IDX_REMOVE 0xff05
5574 #define IDX_REMOVE_TIMER 0xff37
5575 #define IDX_SKIP 's'
5576 #define IDX_LIMIT 'l'
5577 #define IDX_KEYSPACE 0xff35
5578 #define IDX_POTFILE_DISABLE 0xff06
5579 #define IDX_DEBUG_MODE 0xff43
5580 #define IDX_DEBUG_FILE 0xff44
5581 #define IDX_INDUCTION_DIR 0xff46
5582 #define IDX_OUTFILE_CHECK_DIR 0xff47
5583 #define IDX_USERNAME 0xff07
5584 #define IDX_FORCE 0xff08
5585 #define IDX_RUNTIME 0xff09
5586 #define IDX_BENCHMARK 'b'
5587 #define IDX_BENCHMARK_REPEATS 0xff78
5588 #define IDX_HASH_MODE 'm'
5589 #define IDX_ATTACK_MODE 'a'
5590 #define IDX_RP_FILE 'r'
5591 #define IDX_RP_GEN 'g'
5592 #define IDX_RP_GEN_FUNC_MIN 0xff10
5593 #define IDX_RP_GEN_FUNC_MAX 0xff11
5594 #define IDX_RP_GEN_SEED 0xff34
5595 #define IDX_RULE_BUF_L 'j'
5596 #define IDX_RULE_BUF_R 'k'
5597 #define IDX_INCREMENT 'i'
5598 #define IDX_INCREMENT_MIN 0xff12
5599 #define IDX_INCREMENT_MAX 0xff13
5600 #define IDX_OUTFILE 'o'
5601 #define IDX_OUTFILE_FORMAT 0xff14
5602 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5603 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5604 #define IDX_RESTORE 0xff15
5605 #define IDX_RESTORE_DISABLE 0xff27
5606 #define IDX_STATUS 0xff17
5607 #define IDX_STATUS_TIMER 0xff18
5608 #define IDX_STATUS_AUTOMAT 0xff50
5609 #define IDX_LOOPBACK 0xff38
5610 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5611 #define IDX_SESSION 0xff19
5612 #define IDX_HEX_CHARSET 0xff20
5613 #define IDX_HEX_SALT 0xff21
5614 #define IDX_HEX_WORDLIST 0xff40
5615 #define IDX_MARKOV_DISABLE 0xff22
5616 #define IDX_MARKOV_CLASSIC 0xff23
5617 #define IDX_MARKOV_THRESHOLD 't'
5618 #define IDX_MARKOV_HCSTAT 0xff24
5619 #define IDX_CPU_AFFINITY 0xff25
5620 #define IDX_OPENCL_DEVICES 'd'
5621 #define IDX_OPENCL_PLATFORMS 0xff72
5622 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5623 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5624 #define IDX_WORKLOAD_PROFILE 'w'
5625 #define IDX_KERNEL_ACCEL 'n'
5626 #define IDX_KERNEL_LOOPS 'u'
5627 #define IDX_GPU_TEMP_DISABLE 0xff29
5628 #define IDX_GPU_TEMP_ABORT 0xff30
5629 #define IDX_GPU_TEMP_RETAIN 0xff31
5630 #define IDX_POWERTUNE_ENABLE 0xff41
5631 #define IDX_LOGFILE_DISABLE 0xff51
5632 #define IDX_TRUECRYPT_KEYFILES 0xff52
5633 #define IDX_SCRYPT_TMTO 0xff61
5634 #define IDX_SEGMENT_SIZE 'c'
5635 #define IDX_SEPARATOR 'p'
5636 #define IDX_BITMAP_MIN 0xff70
5637 #define IDX_BITMAP_MAX 0xff71
5638 #define IDX_CUSTOM_CHARSET_1 '1'
5639 #define IDX_CUSTOM_CHARSET_2 '2'
5640 #define IDX_CUSTOM_CHARSET_3 '3'
5641 #define IDX_CUSTOM_CHARSET_4 '4'
5642
5643 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5644
5645 struct option long_options[] =
5646 {
5647 {"help", no_argument, 0, IDX_HELP},
5648 {"version", no_argument, 0, IDX_VERSION},
5649 {"quiet", no_argument, 0, IDX_QUIET},
5650 {"show", no_argument, 0, IDX_SHOW},
5651 {"left", no_argument, 0, IDX_LEFT},
5652 {"username", no_argument, 0, IDX_USERNAME},
5653 {"remove", no_argument, 0, IDX_REMOVE},
5654 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5655 {"skip", required_argument, 0, IDX_SKIP},
5656 {"limit", required_argument, 0, IDX_LIMIT},
5657 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5658 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5659 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5660 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5661 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5662 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5663 {"force", no_argument, 0, IDX_FORCE},
5664 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5665 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5666 {"restore", no_argument, 0, IDX_RESTORE},
5667 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5668 {"status", no_argument, 0, IDX_STATUS},
5669 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5670 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5671 {"loopback", no_argument, 0, IDX_LOOPBACK},
5672 {"weak-hash-threshold",
5673 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5674 {"session", required_argument, 0, IDX_SESSION},
5675 {"runtime", required_argument, 0, IDX_RUNTIME},
5676 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5677 {"generate-rules-func-min",
5678 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5679 {"generate-rules-func-max",
5680 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5681 {"generate-rules-seed",
5682 required_argument, 0, IDX_RP_GEN_SEED},
5683 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5684 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5685 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5686 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5687 {"rules-file", required_argument, 0, IDX_RP_FILE},
5688 {"outfile", required_argument, 0, IDX_OUTFILE},
5689 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5690 {"outfile-autohex-disable",
5691 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5692 {"outfile-check-timer",
5693 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5694 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5695 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5696 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5697 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5698 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5699 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5700 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5701 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5702 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5703 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5704 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5705 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5706 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5707 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5708 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5709 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5710 #ifdef HAVE_HWMON
5711 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5712 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5713 #ifdef HAVE_ADL
5714 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5715 #endif
5716 #endif // HAVE_HWMON
5717 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5718 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5719 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5720 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5721 // deprecated
5722 {"seperator", required_argument, 0, IDX_SEPARATOR},
5723 {"separator", required_argument, 0, IDX_SEPARATOR},
5724 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5725 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5726 {"increment", no_argument, 0, IDX_INCREMENT},
5727 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5728 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5729 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5730 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5731 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5732 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5733
5734 {0, 0, 0, 0}
5735 };
5736
5737 uint rp_files_cnt = 0;
5738
5739 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5740
5741 int option_index = 0;
5742 int c = -1;
5743
5744 optind = 1;
5745 optopt = 0;
5746
5747 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5748 {
5749 switch (c)
5750 {
5751 case IDX_HELP: usage = 1; break;
5752 case IDX_VERSION:
5753 case IDX_VERSION_LOWER: version = 1; break;
5754 case IDX_RESTORE: restore = 1; break;
5755 case IDX_SESSION: session = optarg; break;
5756 case IDX_SHOW: show = 1; break;
5757 case IDX_LEFT: left = 1; break;
5758 case '?': return (-1);
5759 }
5760 }
5761
5762 if (optopt != 0)
5763 {
5764 log_error ("ERROR: Invalid argument specified");
5765
5766 return (-1);
5767 }
5768
5769 /**
5770 * exit functions
5771 */
5772
5773 if (version)
5774 {
5775 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5776
5777 return (0);
5778 }
5779
5780 if (usage)
5781 {
5782 usage_big_print (PROGNAME);
5783
5784 return (0);
5785 }
5786
5787 /**
5788 * session needs to be set, always!
5789 */
5790
5791 if (session == NULL) session = (char *) PROGNAME;
5792
5793 /**
5794 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5795 */
5796
5797 char *exec_path = get_exec_path ();
5798
5799 #ifdef LINUX
5800
5801 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5802 char *resolved_exec_path = realpath (exec_path, NULL);
5803
5804 char *install_dir = get_install_dir (resolved_exec_path);
5805 char *profile_dir = NULL;
5806 char *session_dir = NULL;
5807 char *shared_dir = NULL;
5808
5809 if (strcmp (install_dir, resolved_install_folder) == 0)
5810 {
5811 struct passwd *pw = getpwuid (getuid ());
5812
5813 const char *homedir = pw->pw_dir;
5814
5815 profile_dir = get_profile_dir (homedir);
5816 session_dir = get_session_dir (profile_dir);
5817 shared_dir = strdup (SHARED_FOLDER);
5818
5819 mkdir (profile_dir, 0700);
5820 mkdir (session_dir, 0700);
5821 }
5822 else
5823 {
5824 profile_dir = install_dir;
5825 session_dir = install_dir;
5826 shared_dir = install_dir;
5827 }
5828
5829 myfree (resolved_install_folder);
5830 myfree (resolved_exec_path);
5831
5832 #else
5833
5834 char *install_dir = get_install_dir (exec_path);
5835 char *profile_dir = install_dir;
5836 char *session_dir = install_dir;
5837 char *shared_dir = install_dir;
5838
5839 #endif
5840
5841 data.install_dir = install_dir;
5842 data.profile_dir = profile_dir;
5843 data.session_dir = session_dir;
5844 data.shared_dir = shared_dir;
5845
5846 myfree (exec_path);
5847
5848 /**
5849 * kernel cache, we need to make sure folder exist
5850 */
5851
5852 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5853
5854 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5855
5856 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5857
5858 mkdir (kernels_folder, 0700);
5859
5860 myfree (kernels_folder);
5861
5862 /**
5863 * session
5864 */
5865
5866 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5867
5868 data.session = session;
5869
5870 char *eff_restore_file = (char *) mymalloc (session_size);
5871 char *new_restore_file = (char *) mymalloc (session_size);
5872
5873 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5874 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5875
5876 data.eff_restore_file = eff_restore_file;
5877 data.new_restore_file = new_restore_file;
5878
5879 if (((show == 1) || (left == 1)) && (restore == 1))
5880 {
5881 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5882 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5883
5884 return (-1);
5885 }
5886
5887 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5888 if ((show == 1) || (left == 1))
5889 {
5890 restore_disable = 1;
5891
5892 restore = 0;
5893 }
5894
5895 data.restore_disable = restore_disable;
5896
5897 restore_data_t *rd = init_restore (argc, argv);
5898
5899 data.rd = rd;
5900
5901 /**
5902 * restore file
5903 */
5904
5905 if (restore == 1)
5906 {
5907 read_restore (eff_restore_file, rd);
5908
5909 if (rd->version_bin < RESTORE_MIN)
5910 {
5911 log_error ("ERROR: Incompatible restore-file version");
5912
5913 return (-1);
5914 }
5915
5916 myargc = rd->argc;
5917 myargv = rd->argv;
5918
5919 #ifdef _POSIX
5920 rd->pid = getpid ();
5921 #elif _WIN
5922 rd->pid = GetCurrentProcessId ();
5923 #endif
5924 }
5925
5926 uint hash_mode_chgd = 0;
5927 uint runtime_chgd = 0;
5928 uint kernel_loops_chgd = 0;
5929 uint kernel_accel_chgd = 0;
5930 uint attack_mode_chgd = 0;
5931 uint outfile_format_chgd = 0;
5932 uint rp_gen_seed_chgd = 0;
5933 uint remove_timer_chgd = 0;
5934 uint increment_min_chgd = 0;
5935 uint increment_max_chgd = 0;
5936 uint workload_profile_chgd = 0;
5937 uint opencl_vector_width_chgd = 0;
5938
5939 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5940 uint gpu_temp_retain_chgd = 0;
5941 uint gpu_temp_abort_chgd = 0;
5942 #endif
5943
5944 optind = 1;
5945 optopt = 0;
5946 option_index = 0;
5947
5948 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5949 {
5950 switch (c)
5951 {
5952 //case IDX_HELP: usage = 1; break;
5953 //case IDX_VERSION: version = 1; break;
5954 //case IDX_RESTORE: restore = 1; break;
5955 case IDX_QUIET: quiet = 1; break;
5956 //case IDX_SHOW: show = 1; break;
5957 case IDX_SHOW: break;
5958 //case IDX_LEFT: left = 1; break;
5959 case IDX_LEFT: break;
5960 case IDX_USERNAME: username = 1; break;
5961 case IDX_REMOVE: remove = 1; break;
5962 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5963 remove_timer_chgd = 1; break;
5964 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5965 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5966 case IDX_DEBUG_FILE: debug_file = optarg; break;
5967 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5968 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5969 case IDX_FORCE: force = 1; break;
5970 case IDX_SKIP: skip = atoll (optarg); break;
5971 case IDX_LIMIT: limit = atoll (optarg); break;
5972 case IDX_KEYSPACE: keyspace = 1; break;
5973 case IDX_BENCHMARK: benchmark = 1; break;
5974 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5975 case IDX_RESTORE: break;
5976 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5977 case IDX_STATUS: status = 1; break;
5978 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5979 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5980 case IDX_LOOPBACK: loopback = 1; break;
5981 case IDX_WEAK_HASH_THRESHOLD:
5982 weak_hash_threshold = atoi (optarg); break;
5983 //case IDX_SESSION: session = optarg; break;
5984 case IDX_SESSION: break;
5985 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5986 hash_mode_chgd = 1; break;
5987 case IDX_RUNTIME: runtime = atoi (optarg);
5988 runtime_chgd = 1; break;
5989 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5990 attack_mode_chgd = 1; break;
5991 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5992 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5993 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5994 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5995 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5996 rp_gen_seed_chgd = 1; break;
5997 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5998 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5999 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6000 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6001 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6002 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6003 case IDX_OUTFILE: outfile = optarg; break;
6004 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6005 outfile_format_chgd = 1; break;
6006 case IDX_OUTFILE_AUTOHEX_DISABLE:
6007 outfile_autohex = 0; break;
6008 case IDX_OUTFILE_CHECK_TIMER:
6009 outfile_check_timer = atoi (optarg); break;
6010 case IDX_HEX_CHARSET: hex_charset = 1; break;
6011 case IDX_HEX_SALT: hex_salt = 1; break;
6012 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6013 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6014 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6015 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6016 case IDX_OPENCL_DEVICE_TYPES:
6017 opencl_device_types = optarg; break;
6018 case IDX_OPENCL_VECTOR_WIDTH:
6019 opencl_vector_width = atoi (optarg);
6020 opencl_vector_width_chgd = 1; break;
6021 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6022 workload_profile_chgd = 1; break;
6023 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6024 kernel_accel_chgd = 1; break;
6025 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6026 kernel_loops_chgd = 1; break;
6027 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6028 #ifdef HAVE_HWMON
6029 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
6030 #ifdef HAVE_ADL
6031 gpu_temp_abort_chgd = 1;
6032 #endif
6033 break;
6034 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
6035 #ifdef HAVE_ADL
6036 gpu_temp_retain_chgd = 1;
6037 #endif
6038 break;
6039 #ifdef HAVE_ADL
6040 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6041 #endif
6042 #endif // HAVE_HWMON
6043 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6044 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6045 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6046 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6047 case IDX_SEPARATOR: separator = optarg[0]; break;
6048 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6049 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6050 case IDX_INCREMENT: increment = 1; break;
6051 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6052 increment_min_chgd = 1; break;
6053 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6054 increment_max_chgd = 1; break;
6055 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6056 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6057 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6058 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6059
6060 default:
6061 log_error ("ERROR: Invalid argument specified");
6062 return (-1);
6063 }
6064 }
6065
6066 if (optopt != 0)
6067 {
6068 log_error ("ERROR: Invalid argument specified");
6069
6070 return (-1);
6071 }
6072
6073 /**
6074 * Inform user things getting started,
6075 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6076 * - we do not need to check algorithm_pos
6077 */
6078
6079 if (quiet == 0)
6080 {
6081 if (benchmark == 1)
6082 {
6083 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
6084
6085 log_info ("");
6086 }
6087 else if (restore == 1)
6088 {
6089 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
6090
6091 log_info ("");
6092 }
6093 else
6094 {
6095 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
6096
6097 log_info ("");
6098 }
6099 }
6100
6101 /**
6102 * sanity check
6103 */
6104
6105 if (attack_mode > 7)
6106 {
6107 log_error ("ERROR: Invalid attack-mode specified");
6108
6109 return (-1);
6110 }
6111
6112 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6113 {
6114 log_error ("ERROR: Invalid runtime specified");
6115
6116 return (-1);
6117 }
6118
6119 if (hash_mode_chgd && hash_mode > 13100) // just added to remove compiler warnings for hash_mode_chgd
6120 {
6121 log_error ("ERROR: Invalid hash-type specified");
6122
6123 return (-1);
6124 }
6125
6126 // renamed hash modes
6127
6128 if (hash_mode_chgd)
6129 {
6130 int n = -1;
6131
6132 switch (hash_mode)
6133 {
6134 case 123: n = 124;
6135 break;
6136 }
6137
6138 if (n >= 0)
6139 {
6140 log_error ("Old -m specified, use -m %d instead", n);
6141
6142 return (-1);
6143 }
6144 }
6145
6146 if (username == 1)
6147 {
6148 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6149 {
6150 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6151
6152 return (-1);
6153 }
6154 }
6155
6156 if (outfile_format > 16)
6157 {
6158 log_error ("ERROR: Invalid outfile-format specified");
6159
6160 return (-1);
6161 }
6162
6163 if (left == 1)
6164 {
6165 if (outfile_format_chgd == 1)
6166 {
6167 if (outfile_format > 1)
6168 {
6169 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6170
6171 return (-1);
6172 }
6173 }
6174 else
6175 {
6176 outfile_format = OUTFILE_FMT_HASH;
6177 }
6178 }
6179
6180 if (show == 1)
6181 {
6182 if (outfile_format_chgd == 1)
6183 {
6184 if ((outfile_format > 7) && (outfile_format < 16))
6185 {
6186 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6187
6188 return (-1);
6189 }
6190 }
6191 }
6192
6193 if (increment_min < INCREMENT_MIN)
6194 {
6195 log_error ("ERROR: Invalid increment-min specified");
6196
6197 return (-1);
6198 }
6199
6200 if (increment_max > INCREMENT_MAX)
6201 {
6202 log_error ("ERROR: Invalid increment-max specified");
6203
6204 return (-1);
6205 }
6206
6207 if (increment_min > increment_max)
6208 {
6209 log_error ("ERROR: Invalid increment-min specified");
6210
6211 return (-1);
6212 }
6213
6214 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6215 {
6216 log_error ("ERROR: increment is not allowed in attack-mode 0");
6217
6218 return (-1);
6219 }
6220
6221 if ((increment == 0) && (increment_min_chgd == 1))
6222 {
6223 log_error ("ERROR: increment-min is only supported together with increment switch");
6224
6225 return (-1);
6226 }
6227
6228 if ((increment == 0) && (increment_max_chgd == 1))
6229 {
6230 log_error ("ERROR: increment-max is only supported together with increment switch");
6231
6232 return (-1);
6233 }
6234
6235 if (rp_files_cnt && rp_gen)
6236 {
6237 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6238
6239 return (-1);
6240 }
6241
6242 if (rp_files_cnt || rp_gen)
6243 {
6244 if (attack_mode != ATTACK_MODE_STRAIGHT)
6245 {
6246 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6247
6248 return (-1);
6249 }
6250 }
6251
6252 if (rp_gen_func_min > rp_gen_func_max)
6253 {
6254 log_error ("ERROR: Invalid rp-gen-func-min specified");
6255
6256 return (-1);
6257 }
6258
6259 if (kernel_accel_chgd == 1)
6260 {
6261 if (kernel_accel < 1)
6262 {
6263 log_error ("ERROR: Invalid kernel-accel specified");
6264
6265 return (-1);
6266 }
6267
6268 if (kernel_accel > 1024)
6269 {
6270 log_error ("ERROR: Invalid kernel-accel specified");
6271
6272 return (-1);
6273 }
6274 }
6275
6276 if (kernel_loops_chgd == 1)
6277 {
6278 if (kernel_loops < 1)
6279 {
6280 log_error ("ERROR: Invalid kernel-loops specified");
6281
6282 return (-1);
6283 }
6284
6285 if (kernel_loops > 1024)
6286 {
6287 log_error ("ERROR: Invalid kernel-loops specified");
6288
6289 return (-1);
6290 }
6291 }
6292
6293 if ((workload_profile < 1) || (workload_profile > 3))
6294 {
6295 log_error ("ERROR: workload-profile %i not available", workload_profile);
6296
6297 return (-1);
6298 }
6299
6300 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6301 {
6302 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6303
6304 return (-1);
6305 }
6306
6307 if (show == 1 || left == 1)
6308 {
6309 attack_mode = ATTACK_MODE_NONE;
6310
6311 if (remove == 1)
6312 {
6313 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6314
6315 return (-1);
6316 }
6317
6318 if (potfile_disable == 1)
6319 {
6320 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6321
6322 return (-1);
6323 }
6324 }
6325
6326 uint attack_kern = ATTACK_KERN_NONE;
6327
6328 switch (attack_mode)
6329 {
6330 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6331 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6332 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6333 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6334 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6335 }
6336
6337 if (benchmark == 0)
6338 {
6339 if (keyspace == 1)
6340 {
6341 int num_additional_params = 1;
6342
6343 if (attack_kern == ATTACK_KERN_COMBI)
6344 {
6345 num_additional_params = 2;
6346 }
6347
6348 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6349
6350 if (keyspace_wordlist_specified == 0) optind--;
6351 }
6352
6353 if (attack_kern == ATTACK_KERN_NONE)
6354 {
6355 if ((optind + 1) != myargc)
6356 {
6357 usage_mini_print (myargv[0]);
6358
6359 return (-1);
6360 }
6361 }
6362 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6363 {
6364 if ((optind + 1) > myargc)
6365 {
6366 usage_mini_print (myargv[0]);
6367
6368 return (-1);
6369 }
6370 }
6371 else if (attack_kern == ATTACK_KERN_COMBI)
6372 {
6373 if ((optind + 3) != myargc)
6374 {
6375 usage_mini_print (myargv[0]);
6376
6377 return (-1);
6378 }
6379 }
6380 else if (attack_kern == ATTACK_KERN_BF)
6381 {
6382 if ((optind + 1) > myargc)
6383 {
6384 usage_mini_print (myargv[0]);
6385
6386 return (-1);
6387 }
6388 }
6389 else
6390 {
6391 usage_mini_print (myargv[0]);
6392
6393 return (-1);
6394 }
6395 }
6396 else
6397 {
6398 if (myargv[optind] != 0)
6399 {
6400 log_error ("ERROR: Invalid argument for benchmark mode specified");
6401
6402 return (-1);
6403 }
6404
6405 if (attack_mode_chgd == 1)
6406 {
6407 if (attack_mode != ATTACK_MODE_BF)
6408 {
6409 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6410
6411 return (-1);
6412 }
6413 }
6414 }
6415
6416 if (skip != 0 && limit != 0)
6417 {
6418 limit += skip;
6419 }
6420
6421 if (keyspace == 1)
6422 {
6423 if (show == 1)
6424 {
6425 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6426
6427 return (-1);
6428 }
6429 else if (left == 1)
6430 {
6431 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6432
6433 return (-1);
6434 }
6435
6436 potfile_disable = 1;
6437
6438 restore_disable = 1;
6439
6440 restore = 0;
6441
6442 weak_hash_threshold = 0;
6443
6444 quiet = 1;
6445 }
6446
6447 if (remove_timer_chgd == 1)
6448 {
6449 if (remove == 0)
6450 {
6451 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6452
6453 return (-1);
6454 }
6455
6456 if (remove_timer < 1)
6457 {
6458 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6459
6460 return (-1);
6461 }
6462 }
6463
6464 if (loopback == 1)
6465 {
6466 if (attack_mode == ATTACK_MODE_BF)
6467 {
6468 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6469
6470 return (-1);
6471 }
6472 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6473 {
6474 if ((rp_files_cnt == 0) && (rp_gen == 0))
6475 {
6476 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6477
6478 return (-1);
6479 }
6480 }
6481 }
6482
6483 if (debug_mode > 0)
6484 {
6485 if (attack_mode != ATTACK_MODE_STRAIGHT)
6486 {
6487 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6488
6489 return (-1);
6490 }
6491
6492 if ((rp_files_cnt == 0) && (rp_gen == 0))
6493 {
6494 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6495
6496 return (-1);
6497 }
6498 }
6499
6500 if (debug_mode > 4)
6501 {
6502 log_error ("ERROR: Invalid debug-mode specified");
6503
6504 return (-1);
6505 }
6506
6507 if (debug_file != NULL)
6508 {
6509 if (debug_mode < 1)
6510 {
6511 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6512
6513 return (-1);
6514 }
6515 }
6516
6517 if (induction_dir != NULL)
6518 {
6519 if (attack_mode == ATTACK_MODE_BF)
6520 {
6521 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6522
6523 return (-1);
6524 }
6525 }
6526
6527 if (attack_mode != ATTACK_MODE_STRAIGHT)
6528 {
6529 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6530 {
6531 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6532
6533 return (-1);
6534 }
6535
6536 weak_hash_threshold = 0;
6537 }
6538
6539 /**
6540 * induction directory
6541 */
6542
6543 char *induction_directory = NULL;
6544
6545 if (attack_mode != ATTACK_MODE_BF)
6546 {
6547 if (induction_dir == NULL)
6548 {
6549 induction_directory = (char *) mymalloc (session_size);
6550
6551 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6552
6553 // create induction folder if it does not already exist
6554
6555 if (keyspace == 0)
6556 {
6557 if (rmdir (induction_directory) == -1)
6558 {
6559 if (errno == ENOENT)
6560 {
6561 // good, we can ignore
6562 }
6563 else if (errno == ENOTEMPTY)
6564 {
6565 char *induction_directory_mv = (char *) mymalloc (session_size);
6566
6567 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6568
6569 if (rename (induction_directory, induction_directory_mv) != 0)
6570 {
6571 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6572
6573 return (-1);
6574 }
6575 }
6576 else
6577 {
6578 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6579
6580 return (-1);
6581 }
6582 }
6583
6584 if (mkdir (induction_directory, 0700) == -1)
6585 {
6586 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6587
6588 return (-1);
6589 }
6590 }
6591 }
6592 else
6593 {
6594 induction_directory = induction_dir;
6595 }
6596 }
6597
6598 data.induction_directory = induction_directory;
6599
6600 /**
6601 * loopback
6602 */
6603
6604 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6605
6606 char *loopback_file = (char *) mymalloc (loopback_size);
6607
6608 /**
6609 * tuning db
6610 */
6611
6612 char tuning_db_file[256] = { 0 };
6613
6614 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6615
6616 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6617
6618 /**
6619 * outfile-check directory
6620 */
6621
6622 char *outfile_check_directory = NULL;
6623
6624 if (outfile_check_dir == NULL)
6625 {
6626 outfile_check_directory = (char *) mymalloc (session_size);
6627
6628 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6629 }
6630 else
6631 {
6632 outfile_check_directory = outfile_check_dir;
6633 }
6634
6635 data.outfile_check_directory = outfile_check_directory;
6636
6637 if (keyspace == 0)
6638 {
6639 struct stat outfile_check_stat;
6640
6641 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6642 {
6643 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6644
6645 if (is_dir == 0)
6646 {
6647 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6648
6649 return (-1);
6650 }
6651 }
6652 else if (outfile_check_dir == NULL)
6653 {
6654 if (mkdir (outfile_check_directory, 0700) == -1)
6655 {
6656 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6657
6658 return (-1);
6659 }
6660 }
6661 }
6662
6663 /**
6664 * special other stuff
6665 */
6666
6667 if (hash_mode == 9710)
6668 {
6669 outfile_format = 5;
6670 outfile_format_chgd = 1;
6671 }
6672
6673 if (hash_mode == 9810)
6674 {
6675 outfile_format = 5;
6676 outfile_format_chgd = 1;
6677 }
6678
6679 if (hash_mode == 10410)
6680 {
6681 outfile_format = 5;
6682 outfile_format_chgd = 1;
6683 }
6684
6685 /**
6686 * store stuff
6687 */
6688
6689 data.hash_mode = hash_mode;
6690 data.restore = restore;
6691 data.restore_timer = restore_timer;
6692 data.restore_disable = restore_disable;
6693 data.status = status;
6694 data.status_timer = status_timer;
6695 data.status_automat = status_automat;
6696 data.loopback = loopback;
6697 data.runtime = runtime;
6698 data.remove = remove;
6699 data.remove_timer = remove_timer;
6700 data.debug_mode = debug_mode;
6701 data.debug_file = debug_file;
6702 data.username = username;
6703 data.quiet = quiet;
6704 data.outfile = outfile;
6705 data.outfile_format = outfile_format;
6706 data.outfile_autohex = outfile_autohex;
6707 data.hex_charset = hex_charset;
6708 data.hex_salt = hex_salt;
6709 data.hex_wordlist = hex_wordlist;
6710 data.separator = separator;
6711 data.rp_files = rp_files;
6712 data.rp_files_cnt = rp_files_cnt;
6713 data.rp_gen = rp_gen;
6714 data.rp_gen_seed = rp_gen_seed;
6715 data.force = force;
6716 data.benchmark = benchmark;
6717 data.benchmark_repeats = benchmark_repeats;
6718 data.skip = skip;
6719 data.limit = limit;
6720 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6721 data.powertune_enable = powertune_enable;
6722 #endif
6723 data.logfile_disable = logfile_disable;
6724 data.truecrypt_keyfiles = truecrypt_keyfiles;
6725 data.scrypt_tmto = scrypt_tmto;
6726 data.workload_profile = workload_profile;
6727
6728 /**
6729 * cpu affinity
6730 */
6731
6732 if (cpu_affinity)
6733 {
6734 set_cpu_affinity (cpu_affinity);
6735 }
6736
6737 if (rp_gen_seed_chgd == 0)
6738 {
6739 srand (proc_start);
6740 }
6741 else
6742 {
6743 srand (rp_gen_seed);
6744 }
6745
6746 /**
6747 * logfile init
6748 */
6749
6750 if (logfile_disable == 0)
6751 {
6752 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6753
6754 char *logfile = (char *) mymalloc (logfile_size);
6755
6756 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6757
6758 data.logfile = logfile;
6759
6760 char *topid = logfile_generate_topid ();
6761
6762 data.topid = topid;
6763 }
6764
6765 // logfile_append() checks for logfile_disable internally to make it easier from here
6766
6767 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6768 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6769 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6770 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6771 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6772 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6773 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6774 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6775 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6776 #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));
6777
6778 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6779 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6780 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6781 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6782 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6783 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6784 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6785 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6786
6787 logfile_top_msg ("START");
6788
6789 logfile_top_uint (attack_mode);
6790 logfile_top_uint (attack_kern);
6791 logfile_top_uint (benchmark);
6792 logfile_top_uint (benchmark_repeats);
6793 logfile_top_uint (bitmap_min);
6794 logfile_top_uint (bitmap_max);
6795 logfile_top_uint (debug_mode);
6796 logfile_top_uint (force);
6797 logfile_top_uint (kernel_accel);
6798 logfile_top_uint (kernel_loops);
6799 logfile_top_uint (gpu_temp_disable);
6800 #ifdef HAVE_HWMON
6801 logfile_top_uint (gpu_temp_abort);
6802 logfile_top_uint (gpu_temp_retain);
6803 #endif
6804 logfile_top_uint (hash_mode);
6805 logfile_top_uint (hex_charset);
6806 logfile_top_uint (hex_salt);
6807 logfile_top_uint (hex_wordlist);
6808 logfile_top_uint (increment);
6809 logfile_top_uint (increment_max);
6810 logfile_top_uint (increment_min);
6811 logfile_top_uint (keyspace);
6812 logfile_top_uint (left);
6813 logfile_top_uint (logfile_disable);
6814 logfile_top_uint (loopback);
6815 logfile_top_uint (markov_classic);
6816 logfile_top_uint (markov_disable);
6817 logfile_top_uint (markov_threshold);
6818 logfile_top_uint (outfile_autohex);
6819 logfile_top_uint (outfile_check_timer);
6820 logfile_top_uint (outfile_format);
6821 logfile_top_uint (potfile_disable);
6822 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6823 logfile_top_uint (powertune_enable);
6824 #endif
6825 logfile_top_uint (scrypt_tmto);
6826 logfile_top_uint (quiet);
6827 logfile_top_uint (remove);
6828 logfile_top_uint (remove_timer);
6829 logfile_top_uint (restore);
6830 logfile_top_uint (restore_disable);
6831 logfile_top_uint (restore_timer);
6832 logfile_top_uint (rp_gen);
6833 logfile_top_uint (rp_gen_func_max);
6834 logfile_top_uint (rp_gen_func_min);
6835 logfile_top_uint (rp_gen_seed);
6836 logfile_top_uint (runtime);
6837 logfile_top_uint (segment_size);
6838 logfile_top_uint (show);
6839 logfile_top_uint (status);
6840 logfile_top_uint (status_automat);
6841 logfile_top_uint (status_timer);
6842 logfile_top_uint (usage);
6843 logfile_top_uint (username);
6844 logfile_top_uint (version);
6845 logfile_top_uint (weak_hash_threshold);
6846 logfile_top_uint (workload_profile);
6847 logfile_top_uint64 (limit);
6848 logfile_top_uint64 (skip);
6849 logfile_top_char (separator);
6850 logfile_top_string (cpu_affinity);
6851 logfile_top_string (custom_charset_1);
6852 logfile_top_string (custom_charset_2);
6853 logfile_top_string (custom_charset_3);
6854 logfile_top_string (custom_charset_4);
6855 logfile_top_string (debug_file);
6856 logfile_top_string (opencl_devices);
6857 logfile_top_string (opencl_platforms);
6858 logfile_top_string (opencl_device_types);
6859 logfile_top_uint (opencl_vector_width);
6860 logfile_top_string (induction_dir);
6861 logfile_top_string (markov_hcstat);
6862 logfile_top_string (outfile);
6863 logfile_top_string (outfile_check_dir);
6864 logfile_top_string (rule_buf_l);
6865 logfile_top_string (rule_buf_r);
6866 logfile_top_string (session);
6867 logfile_top_string (truecrypt_keyfiles);
6868
6869 /**
6870 * Init OpenCL library loader
6871 */
6872
6873 if (keyspace == 0)
6874 {
6875 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6876
6877 ocl_init (ocl);
6878
6879 data.ocl = ocl;
6880 }
6881
6882 /**
6883 * OpenCL platform selection
6884 */
6885
6886 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6887
6888 /**
6889 * OpenCL device selection
6890 */
6891
6892 u32 devices_filter = setup_devices_filter (opencl_devices);
6893
6894 /**
6895 * OpenCL device type selection
6896 */
6897
6898 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6899
6900 /**
6901 * benchmark
6902 */
6903
6904 if (benchmark == 1)
6905 {
6906 /**
6907 * disable useless stuff for benchmark
6908 */
6909
6910 status_timer = 0;
6911 restore_timer = 0;
6912 restore_disable = 1;
6913 potfile_disable = 1;
6914 weak_hash_threshold = 0;
6915 gpu_temp_disable = 1;
6916
6917 data.status_timer = status_timer;
6918 data.restore_timer = restore_timer;
6919 data.restore_disable = restore_disable;
6920
6921 /**
6922 * force attack mode to be bruteforce
6923 */
6924
6925 attack_mode = ATTACK_MODE_BF;
6926 attack_kern = ATTACK_KERN_BF;
6927
6928 if (workload_profile_chgd == 0)
6929 {
6930 workload_profile = 3;
6931
6932 data.workload_profile = workload_profile;
6933 }
6934 }
6935
6936 /**
6937 * config
6938 */
6939
6940 uint hash_type = 0;
6941 uint salt_type = 0;
6942 uint attack_exec = 0;
6943 uint opts_type = 0;
6944 uint kern_type = 0;
6945 uint dgst_size = 0;
6946 uint esalt_size = 0;
6947 uint opti_type = 0;
6948 uint dgst_pos0 = -1;
6949 uint dgst_pos1 = -1;
6950 uint dgst_pos2 = -1;
6951 uint dgst_pos3 = -1;
6952
6953 int (*parse_func) (char *, uint, hash_t *);
6954 int (*sort_by_digest) (const void *, const void *);
6955
6956 uint algorithm_pos = 0;
6957 uint algorithm_max = 1;
6958
6959 uint *algorithms = default_benchmark_algorithms;
6960
6961 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6962
6963 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6964 {
6965 /*
6966 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6967 * the following algos are skipped entirely
6968 */
6969
6970 if (algorithm_pos > 0)
6971 {
6972 local_free (rd);
6973
6974 rd = init_restore (argc, argv);
6975
6976 data.rd = rd;
6977 }
6978
6979 /**
6980 * update hash_mode in case of multihash benchmark
6981 */
6982
6983 if (benchmark == 1)
6984 {
6985 if (hash_mode_chgd == 0)
6986 {
6987 hash_mode = algorithms[algorithm_pos];
6988
6989 data.hash_mode = hash_mode;
6990 }
6991
6992 quiet = 1;
6993
6994 data.quiet = quiet;
6995 }
6996
6997 switch (hash_mode)
6998 {
6999 case 0: hash_type = HASH_TYPE_MD5;
7000 salt_type = SALT_TYPE_NONE;
7001 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7002 opts_type = OPTS_TYPE_PT_GENERATE_LE
7003 | OPTS_TYPE_PT_ADD80
7004 | OPTS_TYPE_PT_ADDBITS14;
7005 kern_type = KERN_TYPE_MD5;
7006 dgst_size = DGST_SIZE_4_4;
7007 parse_func = md5_parse_hash;
7008 sort_by_digest = sort_by_digest_4_4;
7009 opti_type = OPTI_TYPE_ZERO_BYTE
7010 | OPTI_TYPE_PRECOMPUTE_INIT
7011 | OPTI_TYPE_PRECOMPUTE_MERKLE
7012 | OPTI_TYPE_MEET_IN_MIDDLE
7013 | OPTI_TYPE_EARLY_SKIP
7014 | OPTI_TYPE_NOT_ITERATED
7015 | OPTI_TYPE_NOT_SALTED
7016 | OPTI_TYPE_RAW_HASH;
7017 dgst_pos0 = 0;
7018 dgst_pos1 = 3;
7019 dgst_pos2 = 2;
7020 dgst_pos3 = 1;
7021 break;
7022
7023 case 10: hash_type = HASH_TYPE_MD5;
7024 salt_type = SALT_TYPE_INTERN;
7025 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7026 opts_type = OPTS_TYPE_PT_GENERATE_LE
7027 | OPTS_TYPE_ST_ADD80
7028 | OPTS_TYPE_ST_ADDBITS14;
7029 kern_type = KERN_TYPE_MD5_PWSLT;
7030 dgst_size = DGST_SIZE_4_4;
7031 parse_func = md5s_parse_hash;
7032 sort_by_digest = sort_by_digest_4_4;
7033 opti_type = OPTI_TYPE_ZERO_BYTE
7034 | OPTI_TYPE_PRECOMPUTE_INIT
7035 | OPTI_TYPE_PRECOMPUTE_MERKLE
7036 | OPTI_TYPE_MEET_IN_MIDDLE
7037 | OPTI_TYPE_EARLY_SKIP
7038 | OPTI_TYPE_NOT_ITERATED
7039 | OPTI_TYPE_APPENDED_SALT
7040 | OPTI_TYPE_RAW_HASH;
7041 dgst_pos0 = 0;
7042 dgst_pos1 = 3;
7043 dgst_pos2 = 2;
7044 dgst_pos3 = 1;
7045 break;
7046
7047 case 11: hash_type = HASH_TYPE_MD5;
7048 salt_type = SALT_TYPE_INTERN;
7049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7050 opts_type = OPTS_TYPE_PT_GENERATE_LE
7051 | OPTS_TYPE_ST_ADD80
7052 | OPTS_TYPE_ST_ADDBITS14;
7053 kern_type = KERN_TYPE_MD5_PWSLT;
7054 dgst_size = DGST_SIZE_4_4;
7055 parse_func = joomla_parse_hash;
7056 sort_by_digest = sort_by_digest_4_4;
7057 opti_type = OPTI_TYPE_ZERO_BYTE
7058 | OPTI_TYPE_PRECOMPUTE_INIT
7059 | OPTI_TYPE_PRECOMPUTE_MERKLE
7060 | OPTI_TYPE_MEET_IN_MIDDLE
7061 | OPTI_TYPE_EARLY_SKIP
7062 | OPTI_TYPE_NOT_ITERATED
7063 | OPTI_TYPE_APPENDED_SALT
7064 | OPTI_TYPE_RAW_HASH;
7065 dgst_pos0 = 0;
7066 dgst_pos1 = 3;
7067 dgst_pos2 = 2;
7068 dgst_pos3 = 1;
7069 break;
7070
7071 case 12: hash_type = HASH_TYPE_MD5;
7072 salt_type = SALT_TYPE_INTERN;
7073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7074 opts_type = OPTS_TYPE_PT_GENERATE_LE
7075 | OPTS_TYPE_ST_ADD80
7076 | OPTS_TYPE_ST_ADDBITS14;
7077 kern_type = KERN_TYPE_MD5_PWSLT;
7078 dgst_size = DGST_SIZE_4_4;
7079 parse_func = postgresql_parse_hash;
7080 sort_by_digest = sort_by_digest_4_4;
7081 opti_type = OPTI_TYPE_ZERO_BYTE
7082 | OPTI_TYPE_PRECOMPUTE_INIT
7083 | OPTI_TYPE_PRECOMPUTE_MERKLE
7084 | OPTI_TYPE_MEET_IN_MIDDLE
7085 | OPTI_TYPE_EARLY_SKIP
7086 | OPTI_TYPE_NOT_ITERATED
7087 | OPTI_TYPE_APPENDED_SALT
7088 | OPTI_TYPE_RAW_HASH;
7089 dgst_pos0 = 0;
7090 dgst_pos1 = 3;
7091 dgst_pos2 = 2;
7092 dgst_pos3 = 1;
7093 break;
7094
7095 case 20: hash_type = HASH_TYPE_MD5;
7096 salt_type = SALT_TYPE_INTERN;
7097 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7098 opts_type = OPTS_TYPE_PT_GENERATE_LE
7099 | OPTS_TYPE_PT_ADD80
7100 | OPTS_TYPE_PT_ADDBITS14;
7101 kern_type = KERN_TYPE_MD5_SLTPW;
7102 dgst_size = DGST_SIZE_4_4;
7103 parse_func = md5s_parse_hash;
7104 sort_by_digest = sort_by_digest_4_4;
7105 opti_type = OPTI_TYPE_ZERO_BYTE
7106 | OPTI_TYPE_PRECOMPUTE_INIT
7107 | OPTI_TYPE_PRECOMPUTE_MERKLE
7108 | OPTI_TYPE_EARLY_SKIP
7109 | OPTI_TYPE_NOT_ITERATED
7110 | OPTI_TYPE_PREPENDED_SALT
7111 | OPTI_TYPE_RAW_HASH;
7112 dgst_pos0 = 0;
7113 dgst_pos1 = 3;
7114 dgst_pos2 = 2;
7115 dgst_pos3 = 1;
7116 break;
7117
7118 case 21: hash_type = HASH_TYPE_MD5;
7119 salt_type = SALT_TYPE_INTERN;
7120 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7121 opts_type = OPTS_TYPE_PT_GENERATE_LE
7122 | OPTS_TYPE_PT_ADD80
7123 | OPTS_TYPE_PT_ADDBITS14;
7124 kern_type = KERN_TYPE_MD5_SLTPW;
7125 dgst_size = DGST_SIZE_4_4;
7126 parse_func = osc_parse_hash;
7127 sort_by_digest = sort_by_digest_4_4;
7128 opti_type = OPTI_TYPE_ZERO_BYTE
7129 | OPTI_TYPE_PRECOMPUTE_INIT
7130 | OPTI_TYPE_PRECOMPUTE_MERKLE
7131 | OPTI_TYPE_EARLY_SKIP
7132 | OPTI_TYPE_NOT_ITERATED
7133 | OPTI_TYPE_PREPENDED_SALT
7134 | OPTI_TYPE_RAW_HASH;
7135 dgst_pos0 = 0;
7136 dgst_pos1 = 3;
7137 dgst_pos2 = 2;
7138 dgst_pos3 = 1;
7139 break;
7140
7141 case 22: hash_type = HASH_TYPE_MD5;
7142 salt_type = SALT_TYPE_EMBEDDED;
7143 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7144 opts_type = OPTS_TYPE_PT_GENERATE_LE
7145 | OPTS_TYPE_PT_ADD80
7146 | OPTS_TYPE_PT_ADDBITS14;
7147 kern_type = KERN_TYPE_MD5_SLTPW;
7148 dgst_size = DGST_SIZE_4_4;
7149 parse_func = netscreen_parse_hash;
7150 sort_by_digest = sort_by_digest_4_4;
7151 opti_type = OPTI_TYPE_ZERO_BYTE
7152 | OPTI_TYPE_PRECOMPUTE_INIT
7153 | OPTI_TYPE_PRECOMPUTE_MERKLE
7154 | OPTI_TYPE_EARLY_SKIP
7155 | OPTI_TYPE_NOT_ITERATED
7156 | OPTI_TYPE_PREPENDED_SALT
7157 | OPTI_TYPE_RAW_HASH;
7158 dgst_pos0 = 0;
7159 dgst_pos1 = 3;
7160 dgst_pos2 = 2;
7161 dgst_pos3 = 1;
7162 break;
7163
7164 case 23: hash_type = HASH_TYPE_MD5;
7165 salt_type = SALT_TYPE_EMBEDDED;
7166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7167 opts_type = OPTS_TYPE_PT_GENERATE_LE
7168 | OPTS_TYPE_PT_ADD80
7169 | OPTS_TYPE_PT_ADDBITS14;
7170 kern_type = KERN_TYPE_MD5_SLTPW;
7171 dgst_size = DGST_SIZE_4_4;
7172 parse_func = skype_parse_hash;
7173 sort_by_digest = sort_by_digest_4_4;
7174 opti_type = OPTI_TYPE_ZERO_BYTE
7175 | OPTI_TYPE_PRECOMPUTE_INIT
7176 | OPTI_TYPE_PRECOMPUTE_MERKLE
7177 | OPTI_TYPE_EARLY_SKIP
7178 | OPTI_TYPE_NOT_ITERATED
7179 | OPTI_TYPE_PREPENDED_SALT
7180 | OPTI_TYPE_RAW_HASH;
7181 dgst_pos0 = 0;
7182 dgst_pos1 = 3;
7183 dgst_pos2 = 2;
7184 dgst_pos3 = 1;
7185 break;
7186
7187 case 30: hash_type = HASH_TYPE_MD5;
7188 salt_type = SALT_TYPE_INTERN;
7189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7190 opts_type = OPTS_TYPE_PT_GENERATE_LE
7191 | OPTS_TYPE_PT_UNICODE
7192 | OPTS_TYPE_ST_ADD80
7193 | OPTS_TYPE_ST_ADDBITS14;
7194 kern_type = KERN_TYPE_MD5_PWUSLT;
7195 dgst_size = DGST_SIZE_4_4;
7196 parse_func = md5s_parse_hash;
7197 sort_by_digest = sort_by_digest_4_4;
7198 opti_type = OPTI_TYPE_ZERO_BYTE
7199 | OPTI_TYPE_PRECOMPUTE_INIT
7200 | OPTI_TYPE_PRECOMPUTE_MERKLE
7201 | OPTI_TYPE_MEET_IN_MIDDLE
7202 | OPTI_TYPE_EARLY_SKIP
7203 | OPTI_TYPE_NOT_ITERATED
7204 | OPTI_TYPE_APPENDED_SALT
7205 | OPTI_TYPE_RAW_HASH;
7206 dgst_pos0 = 0;
7207 dgst_pos1 = 3;
7208 dgst_pos2 = 2;
7209 dgst_pos3 = 1;
7210 break;
7211
7212 case 40: hash_type = HASH_TYPE_MD5;
7213 salt_type = SALT_TYPE_INTERN;
7214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7215 opts_type = OPTS_TYPE_PT_GENERATE_LE
7216 | OPTS_TYPE_PT_ADD80
7217 | OPTS_TYPE_PT_ADDBITS14
7218 | OPTS_TYPE_PT_UNICODE;
7219 kern_type = KERN_TYPE_MD5_SLTPWU;
7220 dgst_size = DGST_SIZE_4_4;
7221 parse_func = md5s_parse_hash;
7222 sort_by_digest = sort_by_digest_4_4;
7223 opti_type = OPTI_TYPE_ZERO_BYTE
7224 | OPTI_TYPE_PRECOMPUTE_INIT
7225 | OPTI_TYPE_PRECOMPUTE_MERKLE
7226 | OPTI_TYPE_EARLY_SKIP
7227 | OPTI_TYPE_NOT_ITERATED
7228 | OPTI_TYPE_PREPENDED_SALT
7229 | OPTI_TYPE_RAW_HASH;
7230 dgst_pos0 = 0;
7231 dgst_pos1 = 3;
7232 dgst_pos2 = 2;
7233 dgst_pos3 = 1;
7234 break;
7235
7236 case 50: hash_type = HASH_TYPE_MD5;
7237 salt_type = SALT_TYPE_INTERN;
7238 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7239 opts_type = OPTS_TYPE_PT_GENERATE_LE
7240 | OPTS_TYPE_ST_ADD80
7241 | OPTS_TYPE_ST_ADDBITS14;
7242 kern_type = KERN_TYPE_HMACMD5_PW;
7243 dgst_size = DGST_SIZE_4_4;
7244 parse_func = hmacmd5_parse_hash;
7245 sort_by_digest = sort_by_digest_4_4;
7246 opti_type = OPTI_TYPE_ZERO_BYTE
7247 | OPTI_TYPE_NOT_ITERATED;
7248 dgst_pos0 = 0;
7249 dgst_pos1 = 3;
7250 dgst_pos2 = 2;
7251 dgst_pos3 = 1;
7252 break;
7253
7254 case 60: hash_type = HASH_TYPE_MD5;
7255 salt_type = SALT_TYPE_INTERN;
7256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7257 opts_type = OPTS_TYPE_PT_GENERATE_LE
7258 | OPTS_TYPE_PT_ADD80
7259 | OPTS_TYPE_PT_ADDBITS14;
7260 kern_type = KERN_TYPE_HMACMD5_SLT;
7261 dgst_size = DGST_SIZE_4_4;
7262 parse_func = hmacmd5_parse_hash;
7263 sort_by_digest = sort_by_digest_4_4;
7264 opti_type = OPTI_TYPE_ZERO_BYTE
7265 | OPTI_TYPE_NOT_ITERATED;
7266 dgst_pos0 = 0;
7267 dgst_pos1 = 3;
7268 dgst_pos2 = 2;
7269 dgst_pos3 = 1;
7270 break;
7271
7272 case 100: hash_type = HASH_TYPE_SHA1;
7273 salt_type = SALT_TYPE_NONE;
7274 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7275 opts_type = OPTS_TYPE_PT_GENERATE_BE
7276 | OPTS_TYPE_PT_ADD80
7277 | OPTS_TYPE_PT_ADDBITS15;
7278 kern_type = KERN_TYPE_SHA1;
7279 dgst_size = DGST_SIZE_4_5;
7280 parse_func = sha1_parse_hash;
7281 sort_by_digest = sort_by_digest_4_5;
7282 opti_type = OPTI_TYPE_ZERO_BYTE
7283 | OPTI_TYPE_PRECOMPUTE_INIT
7284 | OPTI_TYPE_PRECOMPUTE_MERKLE
7285 | OPTI_TYPE_EARLY_SKIP
7286 | OPTI_TYPE_NOT_ITERATED
7287 | OPTI_TYPE_NOT_SALTED
7288 | OPTI_TYPE_RAW_HASH;
7289 dgst_pos0 = 3;
7290 dgst_pos1 = 4;
7291 dgst_pos2 = 2;
7292 dgst_pos3 = 1;
7293 break;
7294
7295 case 101: hash_type = HASH_TYPE_SHA1;
7296 salt_type = SALT_TYPE_NONE;
7297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7298 opts_type = OPTS_TYPE_PT_GENERATE_BE
7299 | OPTS_TYPE_PT_ADD80
7300 | OPTS_TYPE_PT_ADDBITS15;
7301 kern_type = KERN_TYPE_SHA1;
7302 dgst_size = DGST_SIZE_4_5;
7303 parse_func = sha1b64_parse_hash;
7304 sort_by_digest = sort_by_digest_4_5;
7305 opti_type = OPTI_TYPE_ZERO_BYTE
7306 | OPTI_TYPE_PRECOMPUTE_INIT
7307 | OPTI_TYPE_PRECOMPUTE_MERKLE
7308 | OPTI_TYPE_EARLY_SKIP
7309 | OPTI_TYPE_NOT_ITERATED
7310 | OPTI_TYPE_NOT_SALTED
7311 | OPTI_TYPE_RAW_HASH;
7312 dgst_pos0 = 3;
7313 dgst_pos1 = 4;
7314 dgst_pos2 = 2;
7315 dgst_pos3 = 1;
7316 break;
7317
7318 case 110: hash_type = HASH_TYPE_SHA1;
7319 salt_type = SALT_TYPE_INTERN;
7320 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7321 opts_type = OPTS_TYPE_PT_GENERATE_BE
7322 | OPTS_TYPE_ST_ADD80
7323 | OPTS_TYPE_ST_ADDBITS15;
7324 kern_type = KERN_TYPE_SHA1_PWSLT;
7325 dgst_size = DGST_SIZE_4_5;
7326 parse_func = sha1s_parse_hash;
7327 sort_by_digest = sort_by_digest_4_5;
7328 opti_type = OPTI_TYPE_ZERO_BYTE
7329 | OPTI_TYPE_PRECOMPUTE_INIT
7330 | OPTI_TYPE_PRECOMPUTE_MERKLE
7331 | OPTI_TYPE_EARLY_SKIP
7332 | OPTI_TYPE_NOT_ITERATED
7333 | OPTI_TYPE_APPENDED_SALT
7334 | OPTI_TYPE_RAW_HASH;
7335 dgst_pos0 = 3;
7336 dgst_pos1 = 4;
7337 dgst_pos2 = 2;
7338 dgst_pos3 = 1;
7339 break;
7340
7341 case 111: hash_type = HASH_TYPE_SHA1;
7342 salt_type = SALT_TYPE_EMBEDDED;
7343 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7344 opts_type = OPTS_TYPE_PT_GENERATE_BE
7345 | OPTS_TYPE_ST_ADD80
7346 | OPTS_TYPE_ST_ADDBITS15;
7347 kern_type = KERN_TYPE_SHA1_PWSLT;
7348 dgst_size = DGST_SIZE_4_5;
7349 parse_func = sha1b64s_parse_hash;
7350 sort_by_digest = sort_by_digest_4_5;
7351 opti_type = OPTI_TYPE_ZERO_BYTE
7352 | OPTI_TYPE_PRECOMPUTE_INIT
7353 | OPTI_TYPE_PRECOMPUTE_MERKLE
7354 | OPTI_TYPE_EARLY_SKIP
7355 | OPTI_TYPE_NOT_ITERATED
7356 | OPTI_TYPE_APPENDED_SALT
7357 | OPTI_TYPE_RAW_HASH;
7358 dgst_pos0 = 3;
7359 dgst_pos1 = 4;
7360 dgst_pos2 = 2;
7361 dgst_pos3 = 1;
7362 break;
7363
7364 case 112: hash_type = HASH_TYPE_SHA1;
7365 salt_type = SALT_TYPE_INTERN;
7366 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7367 opts_type = OPTS_TYPE_PT_GENERATE_BE
7368 | OPTS_TYPE_ST_ADD80
7369 | OPTS_TYPE_ST_ADDBITS15
7370 | OPTS_TYPE_ST_HEX;
7371 kern_type = KERN_TYPE_SHA1_PWSLT;
7372 dgst_size = DGST_SIZE_4_5;
7373 parse_func = oracles_parse_hash;
7374 sort_by_digest = sort_by_digest_4_5;
7375 opti_type = OPTI_TYPE_ZERO_BYTE
7376 | OPTI_TYPE_PRECOMPUTE_INIT
7377 | OPTI_TYPE_PRECOMPUTE_MERKLE
7378 | OPTI_TYPE_EARLY_SKIP
7379 | OPTI_TYPE_NOT_ITERATED
7380 | OPTI_TYPE_APPENDED_SALT
7381 | OPTI_TYPE_RAW_HASH;
7382 dgst_pos0 = 3;
7383 dgst_pos1 = 4;
7384 dgst_pos2 = 2;
7385 dgst_pos3 = 1;
7386 break;
7387
7388 case 120: hash_type = HASH_TYPE_SHA1;
7389 salt_type = SALT_TYPE_INTERN;
7390 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7391 opts_type = OPTS_TYPE_PT_GENERATE_BE
7392 | OPTS_TYPE_PT_ADD80
7393 | OPTS_TYPE_PT_ADDBITS15;
7394 kern_type = KERN_TYPE_SHA1_SLTPW;
7395 dgst_size = DGST_SIZE_4_5;
7396 parse_func = sha1s_parse_hash;
7397 sort_by_digest = sort_by_digest_4_5;
7398 opti_type = OPTI_TYPE_ZERO_BYTE
7399 | OPTI_TYPE_PRECOMPUTE_INIT
7400 | OPTI_TYPE_PRECOMPUTE_MERKLE
7401 | OPTI_TYPE_EARLY_SKIP
7402 | OPTI_TYPE_NOT_ITERATED
7403 | OPTI_TYPE_PREPENDED_SALT
7404 | OPTI_TYPE_RAW_HASH;
7405 dgst_pos0 = 3;
7406 dgst_pos1 = 4;
7407 dgst_pos2 = 2;
7408 dgst_pos3 = 1;
7409 break;
7410
7411 case 121: hash_type = HASH_TYPE_SHA1;
7412 salt_type = SALT_TYPE_INTERN;
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 | OPTS_TYPE_ST_LOWER;
7418 kern_type = KERN_TYPE_SHA1_SLTPW;
7419 dgst_size = DGST_SIZE_4_5;
7420 parse_func = smf_parse_hash;
7421 sort_by_digest = sort_by_digest_4_5;
7422 opti_type = OPTI_TYPE_ZERO_BYTE
7423 | OPTI_TYPE_PRECOMPUTE_INIT
7424 | OPTI_TYPE_PRECOMPUTE_MERKLE
7425 | OPTI_TYPE_EARLY_SKIP
7426 | OPTI_TYPE_NOT_ITERATED
7427 | OPTI_TYPE_PREPENDED_SALT
7428 | OPTI_TYPE_RAW_HASH;
7429 dgst_pos0 = 3;
7430 dgst_pos1 = 4;
7431 dgst_pos2 = 2;
7432 dgst_pos3 = 1;
7433 break;
7434
7435 case 122: hash_type = HASH_TYPE_SHA1;
7436 salt_type = SALT_TYPE_EMBEDDED;
7437 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7438 opts_type = OPTS_TYPE_PT_GENERATE_BE
7439 | OPTS_TYPE_PT_ADD80
7440 | OPTS_TYPE_PT_ADDBITS15
7441 | OPTS_TYPE_ST_HEX;
7442 kern_type = KERN_TYPE_SHA1_SLTPW;
7443 dgst_size = DGST_SIZE_4_5;
7444 parse_func = osx1_parse_hash;
7445 sort_by_digest = sort_by_digest_4_5;
7446 opti_type = OPTI_TYPE_ZERO_BYTE
7447 | OPTI_TYPE_PRECOMPUTE_INIT
7448 | OPTI_TYPE_PRECOMPUTE_MERKLE
7449 | OPTI_TYPE_EARLY_SKIP
7450 | OPTI_TYPE_NOT_ITERATED
7451 | OPTI_TYPE_PREPENDED_SALT
7452 | OPTI_TYPE_RAW_HASH;
7453 dgst_pos0 = 3;
7454 dgst_pos1 = 4;
7455 dgst_pos2 = 2;
7456 dgst_pos3 = 1;
7457 break;
7458
7459 case 124: hash_type = HASH_TYPE_SHA1;
7460 salt_type = SALT_TYPE_EMBEDDED;
7461 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7462 opts_type = OPTS_TYPE_PT_GENERATE_BE
7463 | OPTS_TYPE_PT_ADD80
7464 | OPTS_TYPE_PT_ADDBITS15;
7465 kern_type = KERN_TYPE_SHA1_SLTPW;
7466 dgst_size = DGST_SIZE_4_5;
7467 parse_func = djangosha1_parse_hash;
7468 sort_by_digest = sort_by_digest_4_5;
7469 opti_type = OPTI_TYPE_ZERO_BYTE
7470 | OPTI_TYPE_PRECOMPUTE_INIT
7471 | OPTI_TYPE_PRECOMPUTE_MERKLE
7472 | OPTI_TYPE_EARLY_SKIP
7473 | OPTI_TYPE_NOT_ITERATED
7474 | OPTI_TYPE_PREPENDED_SALT
7475 | OPTI_TYPE_RAW_HASH;
7476 dgst_pos0 = 3;
7477 dgst_pos1 = 4;
7478 dgst_pos2 = 2;
7479 dgst_pos3 = 1;
7480 break;
7481
7482 case 130: hash_type = HASH_TYPE_SHA1;
7483 salt_type = SALT_TYPE_INTERN;
7484 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7485 opts_type = OPTS_TYPE_PT_GENERATE_BE
7486 | OPTS_TYPE_PT_UNICODE
7487 | OPTS_TYPE_ST_ADD80
7488 | OPTS_TYPE_ST_ADDBITS15;
7489 kern_type = KERN_TYPE_SHA1_PWUSLT;
7490 dgst_size = DGST_SIZE_4_5;
7491 parse_func = sha1s_parse_hash;
7492 sort_by_digest = sort_by_digest_4_5;
7493 opti_type = OPTI_TYPE_ZERO_BYTE
7494 | OPTI_TYPE_PRECOMPUTE_INIT
7495 | OPTI_TYPE_PRECOMPUTE_MERKLE
7496 | OPTI_TYPE_EARLY_SKIP
7497 | OPTI_TYPE_NOT_ITERATED
7498 | OPTI_TYPE_APPENDED_SALT
7499 | OPTI_TYPE_RAW_HASH;
7500 dgst_pos0 = 3;
7501 dgst_pos1 = 4;
7502 dgst_pos2 = 2;
7503 dgst_pos3 = 1;
7504 break;
7505
7506 case 131: hash_type = HASH_TYPE_SHA1;
7507 salt_type = SALT_TYPE_EMBEDDED;
7508 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7509 opts_type = OPTS_TYPE_PT_GENERATE_BE
7510 | OPTS_TYPE_PT_UNICODE
7511 | OPTS_TYPE_PT_UPPER
7512 | OPTS_TYPE_ST_ADD80
7513 | OPTS_TYPE_ST_ADDBITS15
7514 | OPTS_TYPE_ST_HEX;
7515 kern_type = KERN_TYPE_SHA1_PWUSLT;
7516 dgst_size = DGST_SIZE_4_5;
7517 parse_func = mssql2000_parse_hash;
7518 sort_by_digest = sort_by_digest_4_5;
7519 opti_type = OPTI_TYPE_ZERO_BYTE
7520 | OPTI_TYPE_PRECOMPUTE_INIT
7521 | OPTI_TYPE_PRECOMPUTE_MERKLE
7522 | OPTI_TYPE_EARLY_SKIP
7523 | OPTI_TYPE_NOT_ITERATED
7524 | OPTI_TYPE_APPENDED_SALT
7525 | OPTI_TYPE_RAW_HASH;
7526 dgst_pos0 = 3;
7527 dgst_pos1 = 4;
7528 dgst_pos2 = 2;
7529 dgst_pos3 = 1;
7530 break;
7531
7532 case 132: hash_type = HASH_TYPE_SHA1;
7533 salt_type = SALT_TYPE_EMBEDDED;
7534 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7535 opts_type = OPTS_TYPE_PT_GENERATE_BE
7536 | OPTS_TYPE_PT_UNICODE
7537 | OPTS_TYPE_ST_ADD80
7538 | OPTS_TYPE_ST_ADDBITS15
7539 | OPTS_TYPE_ST_HEX;
7540 kern_type = KERN_TYPE_SHA1_PWUSLT;
7541 dgst_size = DGST_SIZE_4_5;
7542 parse_func = mssql2005_parse_hash;
7543 sort_by_digest = sort_by_digest_4_5;
7544 opti_type = OPTI_TYPE_ZERO_BYTE
7545 | OPTI_TYPE_PRECOMPUTE_INIT
7546 | OPTI_TYPE_PRECOMPUTE_MERKLE
7547 | OPTI_TYPE_EARLY_SKIP
7548 | OPTI_TYPE_NOT_ITERATED
7549 | OPTI_TYPE_APPENDED_SALT
7550 | OPTI_TYPE_RAW_HASH;
7551 dgst_pos0 = 3;
7552 dgst_pos1 = 4;
7553 dgst_pos2 = 2;
7554 dgst_pos3 = 1;
7555 break;
7556
7557 case 133: hash_type = HASH_TYPE_SHA1;
7558 salt_type = SALT_TYPE_EMBEDDED;
7559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7560 opts_type = OPTS_TYPE_PT_GENERATE_BE
7561 | OPTS_TYPE_PT_UNICODE
7562 | OPTS_TYPE_ST_ADD80
7563 | OPTS_TYPE_ST_ADDBITS15;
7564 kern_type = KERN_TYPE_SHA1_PWUSLT;
7565 dgst_size = DGST_SIZE_4_5;
7566 parse_func = peoplesoft_parse_hash;
7567 sort_by_digest = sort_by_digest_4_5;
7568 opti_type = OPTI_TYPE_ZERO_BYTE
7569 | OPTI_TYPE_PRECOMPUTE_INIT
7570 | OPTI_TYPE_PRECOMPUTE_MERKLE
7571 | OPTI_TYPE_EARLY_SKIP
7572 | OPTI_TYPE_NOT_ITERATED
7573 | OPTI_TYPE_APPENDED_SALT
7574 | OPTI_TYPE_RAW_HASH;
7575 dgst_pos0 = 3;
7576 dgst_pos1 = 4;
7577 dgst_pos2 = 2;
7578 dgst_pos3 = 1;
7579 break;
7580
7581 case 140: hash_type = HASH_TYPE_SHA1;
7582 salt_type = SALT_TYPE_INTERN;
7583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7584 opts_type = OPTS_TYPE_PT_GENERATE_BE
7585 | OPTS_TYPE_PT_ADD80
7586 | OPTS_TYPE_PT_ADDBITS15
7587 | OPTS_TYPE_PT_UNICODE;
7588 kern_type = KERN_TYPE_SHA1_SLTPWU;
7589 dgst_size = DGST_SIZE_4_5;
7590 parse_func = sha1s_parse_hash;
7591 sort_by_digest = sort_by_digest_4_5;
7592 opti_type = OPTI_TYPE_ZERO_BYTE
7593 | OPTI_TYPE_PRECOMPUTE_INIT
7594 | OPTI_TYPE_PRECOMPUTE_MERKLE
7595 | OPTI_TYPE_EARLY_SKIP
7596 | OPTI_TYPE_NOT_ITERATED
7597 | OPTI_TYPE_PREPENDED_SALT
7598 | OPTI_TYPE_RAW_HASH;
7599 dgst_pos0 = 3;
7600 dgst_pos1 = 4;
7601 dgst_pos2 = 2;
7602 dgst_pos3 = 1;
7603 break;
7604
7605 case 141: hash_type = HASH_TYPE_SHA1;
7606 salt_type = SALT_TYPE_EMBEDDED;
7607 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7608 opts_type = OPTS_TYPE_PT_GENERATE_BE
7609 | OPTS_TYPE_PT_ADD80
7610 | OPTS_TYPE_PT_ADDBITS15
7611 | OPTS_TYPE_PT_UNICODE
7612 | OPTS_TYPE_ST_BASE64;
7613 kern_type = KERN_TYPE_SHA1_SLTPWU;
7614 dgst_size = DGST_SIZE_4_5;
7615 parse_func = episerver_parse_hash;
7616 sort_by_digest = sort_by_digest_4_5;
7617 opti_type = OPTI_TYPE_ZERO_BYTE
7618 | OPTI_TYPE_PRECOMPUTE_INIT
7619 | OPTI_TYPE_PRECOMPUTE_MERKLE
7620 | OPTI_TYPE_EARLY_SKIP
7621 | OPTI_TYPE_NOT_ITERATED
7622 | OPTI_TYPE_PREPENDED_SALT
7623 | OPTI_TYPE_RAW_HASH;
7624 dgst_pos0 = 3;
7625 dgst_pos1 = 4;
7626 dgst_pos2 = 2;
7627 dgst_pos3 = 1;
7628 break;
7629
7630 case 150: hash_type = HASH_TYPE_SHA1;
7631 salt_type = SALT_TYPE_INTERN;
7632 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7633 opts_type = OPTS_TYPE_PT_GENERATE_BE
7634 | OPTS_TYPE_ST_ADD80
7635 | OPTS_TYPE_ST_ADDBITS15;
7636 kern_type = KERN_TYPE_HMACSHA1_PW;
7637 dgst_size = DGST_SIZE_4_5;
7638 parse_func = hmacsha1_parse_hash;
7639 sort_by_digest = sort_by_digest_4_5;
7640 opti_type = OPTI_TYPE_ZERO_BYTE
7641 | OPTI_TYPE_NOT_ITERATED;
7642 dgst_pos0 = 3;
7643 dgst_pos1 = 4;
7644 dgst_pos2 = 2;
7645 dgst_pos3 = 1;
7646 break;
7647
7648 case 160: hash_type = HASH_TYPE_SHA1;
7649 salt_type = SALT_TYPE_INTERN;
7650 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7651 opts_type = OPTS_TYPE_PT_GENERATE_BE
7652 | OPTS_TYPE_PT_ADD80
7653 | OPTS_TYPE_PT_ADDBITS15;
7654 kern_type = KERN_TYPE_HMACSHA1_SLT;
7655 dgst_size = DGST_SIZE_4_5;
7656 parse_func = hmacsha1_parse_hash;
7657 sort_by_digest = sort_by_digest_4_5;
7658 opti_type = OPTI_TYPE_ZERO_BYTE
7659 | OPTI_TYPE_NOT_ITERATED;
7660 dgst_pos0 = 3;
7661 dgst_pos1 = 4;
7662 dgst_pos2 = 2;
7663 dgst_pos3 = 1;
7664 break;
7665
7666 case 190: hash_type = HASH_TYPE_SHA1;
7667 salt_type = SALT_TYPE_NONE;
7668 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7669 opts_type = OPTS_TYPE_PT_GENERATE_BE
7670 | OPTS_TYPE_PT_ADD80
7671 | OPTS_TYPE_PT_ADDBITS15;
7672 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7673 dgst_size = DGST_SIZE_4_5;
7674 parse_func = sha1linkedin_parse_hash;
7675 sort_by_digest = sort_by_digest_4_5;
7676 opti_type = OPTI_TYPE_ZERO_BYTE
7677 | OPTI_TYPE_PRECOMPUTE_INIT
7678 | OPTI_TYPE_EARLY_SKIP
7679 | OPTI_TYPE_NOT_ITERATED
7680 | OPTI_TYPE_NOT_SALTED;
7681 dgst_pos0 = 0;
7682 dgst_pos1 = 4;
7683 dgst_pos2 = 3;
7684 dgst_pos3 = 2;
7685 break;
7686
7687 case 200: hash_type = HASH_TYPE_MYSQL;
7688 salt_type = SALT_TYPE_NONE;
7689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7690 opts_type = 0;
7691 kern_type = KERN_TYPE_MYSQL;
7692 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7693 parse_func = mysql323_parse_hash;
7694 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7695 opti_type = OPTI_TYPE_ZERO_BYTE;
7696 dgst_pos0 = 0;
7697 dgst_pos1 = 1;
7698 dgst_pos2 = 2;
7699 dgst_pos3 = 3;
7700 break;
7701
7702 case 300: hash_type = HASH_TYPE_SHA1;
7703 salt_type = SALT_TYPE_NONE;
7704 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7705 opts_type = OPTS_TYPE_PT_GENERATE_BE
7706 | OPTS_TYPE_PT_ADD80
7707 | OPTS_TYPE_PT_ADDBITS15;
7708 kern_type = KERN_TYPE_MYSQL41;
7709 dgst_size = DGST_SIZE_4_5;
7710 parse_func = sha1_parse_hash;
7711 sort_by_digest = sort_by_digest_4_5;
7712 opti_type = OPTI_TYPE_ZERO_BYTE
7713 | OPTI_TYPE_PRECOMPUTE_INIT
7714 | OPTI_TYPE_PRECOMPUTE_MERKLE
7715 | OPTI_TYPE_EARLY_SKIP
7716 | OPTI_TYPE_NOT_ITERATED
7717 | OPTI_TYPE_NOT_SALTED;
7718 dgst_pos0 = 3;
7719 dgst_pos1 = 4;
7720 dgst_pos2 = 2;
7721 dgst_pos3 = 1;
7722 break;
7723
7724 case 400: hash_type = HASH_TYPE_MD5;
7725 salt_type = SALT_TYPE_EMBEDDED;
7726 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7727 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7728 kern_type = KERN_TYPE_PHPASS;
7729 dgst_size = DGST_SIZE_4_4;
7730 parse_func = phpass_parse_hash;
7731 sort_by_digest = sort_by_digest_4_4;
7732 opti_type = OPTI_TYPE_ZERO_BYTE;
7733 dgst_pos0 = 0;
7734 dgst_pos1 = 1;
7735 dgst_pos2 = 2;
7736 dgst_pos3 = 3;
7737 break;
7738
7739 case 500: hash_type = HASH_TYPE_MD5;
7740 salt_type = SALT_TYPE_EMBEDDED;
7741 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7742 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7743 kern_type = KERN_TYPE_MD5CRYPT;
7744 dgst_size = DGST_SIZE_4_4;
7745 parse_func = md5crypt_parse_hash;
7746 sort_by_digest = sort_by_digest_4_4;
7747 opti_type = OPTI_TYPE_ZERO_BYTE;
7748 dgst_pos0 = 0;
7749 dgst_pos1 = 1;
7750 dgst_pos2 = 2;
7751 dgst_pos3 = 3;
7752 break;
7753
7754 case 501: hash_type = HASH_TYPE_MD5;
7755 salt_type = SALT_TYPE_EMBEDDED;
7756 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7757 opts_type = OPTS_TYPE_PT_GENERATE_LE
7758 | OPTS_TYPE_HASH_COPY;
7759 kern_type = KERN_TYPE_MD5CRYPT;
7760 dgst_size = DGST_SIZE_4_4;
7761 parse_func = juniper_parse_hash;
7762 sort_by_digest = sort_by_digest_4_4;
7763 opti_type = OPTI_TYPE_ZERO_BYTE;
7764 dgst_pos0 = 0;
7765 dgst_pos1 = 1;
7766 dgst_pos2 = 2;
7767 dgst_pos3 = 3;
7768 break;
7769
7770 case 900: hash_type = HASH_TYPE_MD4;
7771 salt_type = SALT_TYPE_NONE;
7772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7773 opts_type = OPTS_TYPE_PT_GENERATE_LE
7774 | OPTS_TYPE_PT_ADD80
7775 | OPTS_TYPE_PT_ADDBITS14;
7776 kern_type = KERN_TYPE_MD4;
7777 dgst_size = DGST_SIZE_4_4;
7778 parse_func = md4_parse_hash;
7779 sort_by_digest = sort_by_digest_4_4;
7780 opti_type = OPTI_TYPE_ZERO_BYTE
7781 | OPTI_TYPE_PRECOMPUTE_INIT
7782 | OPTI_TYPE_PRECOMPUTE_MERKLE
7783 | OPTI_TYPE_MEET_IN_MIDDLE
7784 | OPTI_TYPE_EARLY_SKIP
7785 | OPTI_TYPE_NOT_ITERATED
7786 | OPTI_TYPE_NOT_SALTED
7787 | OPTI_TYPE_RAW_HASH;
7788 dgst_pos0 = 0;
7789 dgst_pos1 = 3;
7790 dgst_pos2 = 2;
7791 dgst_pos3 = 1;
7792 break;
7793
7794 case 1000: hash_type = HASH_TYPE_MD4;
7795 salt_type = SALT_TYPE_NONE;
7796 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7797 opts_type = OPTS_TYPE_PT_GENERATE_LE
7798 | OPTS_TYPE_PT_ADD80
7799 | OPTS_TYPE_PT_ADDBITS14
7800 | OPTS_TYPE_PT_UNICODE;
7801 kern_type = KERN_TYPE_MD4_PWU;
7802 dgst_size = DGST_SIZE_4_4;
7803 parse_func = md4_parse_hash;
7804 sort_by_digest = sort_by_digest_4_4;
7805 opti_type = OPTI_TYPE_ZERO_BYTE
7806 | OPTI_TYPE_PRECOMPUTE_INIT
7807 | OPTI_TYPE_PRECOMPUTE_MERKLE
7808 | OPTI_TYPE_MEET_IN_MIDDLE
7809 | OPTI_TYPE_EARLY_SKIP
7810 | OPTI_TYPE_NOT_ITERATED
7811 | OPTI_TYPE_NOT_SALTED
7812 | OPTI_TYPE_RAW_HASH;
7813 dgst_pos0 = 0;
7814 dgst_pos1 = 3;
7815 dgst_pos2 = 2;
7816 dgst_pos3 = 1;
7817 break;
7818
7819 case 1100: hash_type = HASH_TYPE_MD4;
7820 salt_type = SALT_TYPE_INTERN;
7821 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7822 opts_type = OPTS_TYPE_PT_GENERATE_LE
7823 | OPTS_TYPE_PT_ADD80
7824 | OPTS_TYPE_PT_ADDBITS14
7825 | OPTS_TYPE_PT_UNICODE
7826 | OPTS_TYPE_ST_ADD80
7827 | OPTS_TYPE_ST_UNICODE
7828 | OPTS_TYPE_ST_LOWER;
7829 kern_type = KERN_TYPE_MD44_PWUSLT;
7830 dgst_size = DGST_SIZE_4_4;
7831 parse_func = dcc_parse_hash;
7832 sort_by_digest = sort_by_digest_4_4;
7833 opti_type = OPTI_TYPE_ZERO_BYTE
7834 | OPTI_TYPE_PRECOMPUTE_INIT
7835 | OPTI_TYPE_PRECOMPUTE_MERKLE
7836 | OPTI_TYPE_EARLY_SKIP
7837 | OPTI_TYPE_NOT_ITERATED;
7838 dgst_pos0 = 0;
7839 dgst_pos1 = 3;
7840 dgst_pos2 = 2;
7841 dgst_pos3 = 1;
7842 break;
7843
7844 case 1400: hash_type = HASH_TYPE_SHA256;
7845 salt_type = SALT_TYPE_NONE;
7846 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7847 opts_type = OPTS_TYPE_PT_GENERATE_BE
7848 | OPTS_TYPE_PT_ADD80
7849 | OPTS_TYPE_PT_ADDBITS15;
7850 kern_type = KERN_TYPE_SHA256;
7851 dgst_size = DGST_SIZE_4_8;
7852 parse_func = sha256_parse_hash;
7853 sort_by_digest = sort_by_digest_4_8;
7854 opti_type = OPTI_TYPE_ZERO_BYTE
7855 | OPTI_TYPE_PRECOMPUTE_INIT
7856 | OPTI_TYPE_PRECOMPUTE_MERKLE
7857 | OPTI_TYPE_EARLY_SKIP
7858 | OPTI_TYPE_NOT_ITERATED
7859 | OPTI_TYPE_NOT_SALTED
7860 | OPTI_TYPE_RAW_HASH;
7861 dgst_pos0 = 3;
7862 dgst_pos1 = 7;
7863 dgst_pos2 = 2;
7864 dgst_pos3 = 6;
7865 break;
7866
7867 case 1410: hash_type = HASH_TYPE_SHA256;
7868 salt_type = SALT_TYPE_INTERN;
7869 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7870 opts_type = OPTS_TYPE_PT_GENERATE_BE
7871 | OPTS_TYPE_ST_ADD80
7872 | OPTS_TYPE_ST_ADDBITS15;
7873 kern_type = KERN_TYPE_SHA256_PWSLT;
7874 dgst_size = DGST_SIZE_4_8;
7875 parse_func = sha256s_parse_hash;
7876 sort_by_digest = sort_by_digest_4_8;
7877 opti_type = OPTI_TYPE_ZERO_BYTE
7878 | OPTI_TYPE_PRECOMPUTE_INIT
7879 | OPTI_TYPE_PRECOMPUTE_MERKLE
7880 | OPTI_TYPE_EARLY_SKIP
7881 | OPTI_TYPE_NOT_ITERATED
7882 | OPTI_TYPE_APPENDED_SALT
7883 | OPTI_TYPE_RAW_HASH;
7884 dgst_pos0 = 3;
7885 dgst_pos1 = 7;
7886 dgst_pos2 = 2;
7887 dgst_pos3 = 6;
7888 break;
7889
7890 case 1420: hash_type = HASH_TYPE_SHA256;
7891 salt_type = SALT_TYPE_INTERN;
7892 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7893 opts_type = OPTS_TYPE_PT_GENERATE_BE
7894 | OPTS_TYPE_PT_ADD80
7895 | OPTS_TYPE_PT_ADDBITS15;
7896 kern_type = KERN_TYPE_SHA256_SLTPW;
7897 dgst_size = DGST_SIZE_4_8;
7898 parse_func = sha256s_parse_hash;
7899 sort_by_digest = sort_by_digest_4_8;
7900 opti_type = OPTI_TYPE_ZERO_BYTE
7901 | OPTI_TYPE_PRECOMPUTE_INIT
7902 | OPTI_TYPE_PRECOMPUTE_MERKLE
7903 | OPTI_TYPE_EARLY_SKIP
7904 | OPTI_TYPE_NOT_ITERATED
7905 | OPTI_TYPE_PREPENDED_SALT
7906 | OPTI_TYPE_RAW_HASH;
7907 dgst_pos0 = 3;
7908 dgst_pos1 = 7;
7909 dgst_pos2 = 2;
7910 dgst_pos3 = 6;
7911 break;
7912
7913 case 1421: hash_type = HASH_TYPE_SHA256;
7914 salt_type = SALT_TYPE_EMBEDDED;
7915 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7916 opts_type = OPTS_TYPE_PT_GENERATE_BE
7917 | OPTS_TYPE_PT_ADD80
7918 | OPTS_TYPE_PT_ADDBITS15;
7919 kern_type = KERN_TYPE_SHA256_SLTPW;
7920 dgst_size = DGST_SIZE_4_8;
7921 parse_func = hmailserver_parse_hash;
7922 sort_by_digest = sort_by_digest_4_8;
7923 opti_type = OPTI_TYPE_ZERO_BYTE
7924 | OPTI_TYPE_PRECOMPUTE_INIT
7925 | OPTI_TYPE_PRECOMPUTE_MERKLE
7926 | OPTI_TYPE_EARLY_SKIP
7927 | OPTI_TYPE_NOT_ITERATED
7928 | OPTI_TYPE_PREPENDED_SALT
7929 | OPTI_TYPE_RAW_HASH;
7930 dgst_pos0 = 3;
7931 dgst_pos1 = 7;
7932 dgst_pos2 = 2;
7933 dgst_pos3 = 6;
7934 break;
7935
7936 case 1430: hash_type = HASH_TYPE_SHA256;
7937 salt_type = SALT_TYPE_INTERN;
7938 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7939 opts_type = OPTS_TYPE_PT_GENERATE_BE
7940 | OPTS_TYPE_PT_UNICODE
7941 | OPTS_TYPE_ST_ADD80
7942 | OPTS_TYPE_ST_ADDBITS15;
7943 kern_type = KERN_TYPE_SHA256_PWUSLT;
7944 dgst_size = DGST_SIZE_4_8;
7945 parse_func = sha256s_parse_hash;
7946 sort_by_digest = sort_by_digest_4_8;
7947 opti_type = OPTI_TYPE_ZERO_BYTE
7948 | OPTI_TYPE_PRECOMPUTE_INIT
7949 | OPTI_TYPE_PRECOMPUTE_MERKLE
7950 | OPTI_TYPE_EARLY_SKIP
7951 | OPTI_TYPE_NOT_ITERATED
7952 | OPTI_TYPE_APPENDED_SALT
7953 | OPTI_TYPE_RAW_HASH;
7954 dgst_pos0 = 3;
7955 dgst_pos1 = 7;
7956 dgst_pos2 = 2;
7957 dgst_pos3 = 6;
7958 break;
7959
7960 case 1440: hash_type = HASH_TYPE_SHA256;
7961 salt_type = SALT_TYPE_INTERN;
7962 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7963 opts_type = OPTS_TYPE_PT_GENERATE_BE
7964 | OPTS_TYPE_PT_ADD80
7965 | OPTS_TYPE_PT_ADDBITS15
7966 | OPTS_TYPE_PT_UNICODE;
7967 kern_type = KERN_TYPE_SHA256_SLTPWU;
7968 dgst_size = DGST_SIZE_4_8;
7969 parse_func = sha256s_parse_hash;
7970 sort_by_digest = sort_by_digest_4_8;
7971 opti_type = OPTI_TYPE_ZERO_BYTE
7972 | OPTI_TYPE_PRECOMPUTE_INIT
7973 | OPTI_TYPE_PRECOMPUTE_MERKLE
7974 | OPTI_TYPE_EARLY_SKIP
7975 | OPTI_TYPE_NOT_ITERATED
7976 | OPTI_TYPE_PREPENDED_SALT
7977 | OPTI_TYPE_RAW_HASH;
7978 dgst_pos0 = 3;
7979 dgst_pos1 = 7;
7980 dgst_pos2 = 2;
7981 dgst_pos3 = 6;
7982 break;
7983
7984 case 1441: hash_type = HASH_TYPE_SHA256;
7985 salt_type = SALT_TYPE_EMBEDDED;
7986 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7987 opts_type = OPTS_TYPE_PT_GENERATE_BE
7988 | OPTS_TYPE_PT_ADD80
7989 | OPTS_TYPE_PT_ADDBITS15
7990 | OPTS_TYPE_PT_UNICODE
7991 | OPTS_TYPE_ST_BASE64;
7992 kern_type = KERN_TYPE_SHA256_SLTPWU;
7993 dgst_size = DGST_SIZE_4_8;
7994 parse_func = episerver4_parse_hash;
7995 sort_by_digest = sort_by_digest_4_8;
7996 opti_type = OPTI_TYPE_ZERO_BYTE
7997 | OPTI_TYPE_PRECOMPUTE_INIT
7998 | OPTI_TYPE_PRECOMPUTE_MERKLE
7999 | OPTI_TYPE_EARLY_SKIP
8000 | OPTI_TYPE_NOT_ITERATED
8001 | OPTI_TYPE_PREPENDED_SALT
8002 | OPTI_TYPE_RAW_HASH;
8003 dgst_pos0 = 3;
8004 dgst_pos1 = 7;
8005 dgst_pos2 = 2;
8006 dgst_pos3 = 6;
8007 break;
8008
8009 case 1450: hash_type = HASH_TYPE_SHA256;
8010 salt_type = SALT_TYPE_INTERN;
8011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8012 opts_type = OPTS_TYPE_PT_GENERATE_BE
8013 | OPTS_TYPE_ST_ADD80;
8014 kern_type = KERN_TYPE_HMACSHA256_PW;
8015 dgst_size = DGST_SIZE_4_8;
8016 parse_func = hmacsha256_parse_hash;
8017 sort_by_digest = sort_by_digest_4_8;
8018 opti_type = OPTI_TYPE_ZERO_BYTE
8019 | OPTI_TYPE_NOT_ITERATED;
8020 dgst_pos0 = 3;
8021 dgst_pos1 = 7;
8022 dgst_pos2 = 2;
8023 dgst_pos3 = 6;
8024 break;
8025
8026 case 1460: hash_type = HASH_TYPE_SHA256;
8027 salt_type = SALT_TYPE_INTERN;
8028 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8029 opts_type = OPTS_TYPE_PT_GENERATE_BE
8030 | OPTS_TYPE_PT_ADD80
8031 | OPTS_TYPE_PT_ADDBITS15;
8032 kern_type = KERN_TYPE_HMACSHA256_SLT;
8033 dgst_size = DGST_SIZE_4_8;
8034 parse_func = hmacsha256_parse_hash;
8035 sort_by_digest = sort_by_digest_4_8;
8036 opti_type = OPTI_TYPE_ZERO_BYTE
8037 | OPTI_TYPE_NOT_ITERATED;
8038 dgst_pos0 = 3;
8039 dgst_pos1 = 7;
8040 dgst_pos2 = 2;
8041 dgst_pos3 = 6;
8042 break;
8043
8044 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8045 salt_type = SALT_TYPE_EMBEDDED;
8046 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8047 opts_type = OPTS_TYPE_PT_GENERATE_LE
8048 | OPTS_TYPE_PT_BITSLICE;
8049 kern_type = KERN_TYPE_DESCRYPT;
8050 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8051 parse_func = descrypt_parse_hash;
8052 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8053 opti_type = OPTI_TYPE_ZERO_BYTE
8054 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8055 dgst_pos0 = 0;
8056 dgst_pos1 = 1;
8057 dgst_pos2 = 2;
8058 dgst_pos3 = 3;
8059 break;
8060
8061 case 1600: hash_type = HASH_TYPE_MD5;
8062 salt_type = SALT_TYPE_EMBEDDED;
8063 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8064 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8065 kern_type = KERN_TYPE_APR1CRYPT;
8066 dgst_size = DGST_SIZE_4_4;
8067 parse_func = md5apr1_parse_hash;
8068 sort_by_digest = sort_by_digest_4_4;
8069 opti_type = OPTI_TYPE_ZERO_BYTE;
8070 dgst_pos0 = 0;
8071 dgst_pos1 = 1;
8072 dgst_pos2 = 2;
8073 dgst_pos3 = 3;
8074 break;
8075
8076 case 1700: hash_type = HASH_TYPE_SHA512;
8077 salt_type = SALT_TYPE_NONE;
8078 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8079 opts_type = OPTS_TYPE_PT_GENERATE_BE
8080 | OPTS_TYPE_PT_ADD80
8081 | OPTS_TYPE_PT_ADDBITS15;
8082 kern_type = KERN_TYPE_SHA512;
8083 dgst_size = DGST_SIZE_8_8;
8084 parse_func = sha512_parse_hash;
8085 sort_by_digest = sort_by_digest_8_8;
8086 opti_type = OPTI_TYPE_ZERO_BYTE
8087 | OPTI_TYPE_PRECOMPUTE_INIT
8088 | OPTI_TYPE_PRECOMPUTE_MERKLE
8089 | OPTI_TYPE_EARLY_SKIP
8090 | OPTI_TYPE_NOT_ITERATED
8091 | OPTI_TYPE_NOT_SALTED
8092 | OPTI_TYPE_USES_BITS_64
8093 | OPTI_TYPE_RAW_HASH;
8094 dgst_pos0 = 14;
8095 dgst_pos1 = 15;
8096 dgst_pos2 = 6;
8097 dgst_pos3 = 7;
8098 break;
8099
8100 case 1710: hash_type = HASH_TYPE_SHA512;
8101 salt_type = SALT_TYPE_INTERN;
8102 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8103 opts_type = OPTS_TYPE_PT_GENERATE_BE
8104 | OPTS_TYPE_ST_ADD80
8105 | OPTS_TYPE_ST_ADDBITS15;
8106 kern_type = KERN_TYPE_SHA512_PWSLT;
8107 dgst_size = DGST_SIZE_8_8;
8108 parse_func = sha512s_parse_hash;
8109 sort_by_digest = sort_by_digest_8_8;
8110 opti_type = OPTI_TYPE_ZERO_BYTE
8111 | OPTI_TYPE_PRECOMPUTE_INIT
8112 | OPTI_TYPE_PRECOMPUTE_MERKLE
8113 | OPTI_TYPE_EARLY_SKIP
8114 | OPTI_TYPE_NOT_ITERATED
8115 | OPTI_TYPE_APPENDED_SALT
8116 | OPTI_TYPE_USES_BITS_64
8117 | OPTI_TYPE_RAW_HASH;
8118 dgst_pos0 = 14;
8119 dgst_pos1 = 15;
8120 dgst_pos2 = 6;
8121 dgst_pos3 = 7;
8122 break;
8123
8124 case 1711: hash_type = HASH_TYPE_SHA512;
8125 salt_type = SALT_TYPE_EMBEDDED;
8126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8127 opts_type = OPTS_TYPE_PT_GENERATE_BE
8128 | OPTS_TYPE_ST_ADD80
8129 | OPTS_TYPE_ST_ADDBITS15;
8130 kern_type = KERN_TYPE_SHA512_PWSLT;
8131 dgst_size = DGST_SIZE_8_8;
8132 parse_func = sha512b64s_parse_hash;
8133 sort_by_digest = sort_by_digest_8_8;
8134 opti_type = OPTI_TYPE_ZERO_BYTE
8135 | OPTI_TYPE_PRECOMPUTE_INIT
8136 | OPTI_TYPE_PRECOMPUTE_MERKLE
8137 | OPTI_TYPE_EARLY_SKIP
8138 | OPTI_TYPE_NOT_ITERATED
8139 | OPTI_TYPE_APPENDED_SALT
8140 | OPTI_TYPE_USES_BITS_64
8141 | OPTI_TYPE_RAW_HASH;
8142 dgst_pos0 = 14;
8143 dgst_pos1 = 15;
8144 dgst_pos2 = 6;
8145 dgst_pos3 = 7;
8146 break;
8147
8148 case 1720: hash_type = HASH_TYPE_SHA512;
8149 salt_type = SALT_TYPE_INTERN;
8150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8151 opts_type = OPTS_TYPE_PT_GENERATE_BE
8152 | OPTS_TYPE_PT_ADD80
8153 | OPTS_TYPE_PT_ADDBITS15;
8154 kern_type = KERN_TYPE_SHA512_SLTPW;
8155 dgst_size = DGST_SIZE_8_8;
8156 parse_func = sha512s_parse_hash;
8157 sort_by_digest = sort_by_digest_8_8;
8158 opti_type = OPTI_TYPE_ZERO_BYTE
8159 | OPTI_TYPE_PRECOMPUTE_INIT
8160 | OPTI_TYPE_PRECOMPUTE_MERKLE
8161 | OPTI_TYPE_EARLY_SKIP
8162 | OPTI_TYPE_NOT_ITERATED
8163 | OPTI_TYPE_PREPENDED_SALT
8164 | OPTI_TYPE_USES_BITS_64
8165 | OPTI_TYPE_RAW_HASH;
8166 dgst_pos0 = 14;
8167 dgst_pos1 = 15;
8168 dgst_pos2 = 6;
8169 dgst_pos3 = 7;
8170 break;
8171
8172 case 1722: hash_type = HASH_TYPE_SHA512;
8173 salt_type = SALT_TYPE_EMBEDDED;
8174 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8175 opts_type = OPTS_TYPE_PT_GENERATE_BE
8176 | OPTS_TYPE_PT_ADD80
8177 | OPTS_TYPE_PT_ADDBITS15
8178 | OPTS_TYPE_ST_HEX;
8179 kern_type = KERN_TYPE_SHA512_SLTPW;
8180 dgst_size = DGST_SIZE_8_8;
8181 parse_func = osx512_parse_hash;
8182 sort_by_digest = sort_by_digest_8_8;
8183 opti_type = OPTI_TYPE_ZERO_BYTE
8184 | OPTI_TYPE_PRECOMPUTE_INIT
8185 | OPTI_TYPE_PRECOMPUTE_MERKLE
8186 | OPTI_TYPE_EARLY_SKIP
8187 | OPTI_TYPE_NOT_ITERATED
8188 | OPTI_TYPE_PREPENDED_SALT
8189 | OPTI_TYPE_USES_BITS_64
8190 | OPTI_TYPE_RAW_HASH;
8191 dgst_pos0 = 14;
8192 dgst_pos1 = 15;
8193 dgst_pos2 = 6;
8194 dgst_pos3 = 7;
8195 break;
8196
8197 case 1730: hash_type = HASH_TYPE_SHA512;
8198 salt_type = SALT_TYPE_INTERN;
8199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8200 opts_type = OPTS_TYPE_PT_GENERATE_BE
8201 | OPTS_TYPE_PT_UNICODE
8202 | OPTS_TYPE_ST_ADD80
8203 | OPTS_TYPE_ST_ADDBITS15;
8204 kern_type = KERN_TYPE_SHA512_PWSLTU;
8205 dgst_size = DGST_SIZE_8_8;
8206 parse_func = sha512s_parse_hash;
8207 sort_by_digest = sort_by_digest_8_8;
8208 opti_type = OPTI_TYPE_ZERO_BYTE
8209 | OPTI_TYPE_PRECOMPUTE_INIT
8210 | OPTI_TYPE_PRECOMPUTE_MERKLE
8211 | OPTI_TYPE_EARLY_SKIP
8212 | OPTI_TYPE_NOT_ITERATED
8213 | OPTI_TYPE_APPENDED_SALT
8214 | OPTI_TYPE_USES_BITS_64
8215 | OPTI_TYPE_RAW_HASH;
8216 dgst_pos0 = 14;
8217 dgst_pos1 = 15;
8218 dgst_pos2 = 6;
8219 dgst_pos3 = 7;
8220 break;
8221
8222 case 1731: hash_type = HASH_TYPE_SHA512;
8223 salt_type = SALT_TYPE_EMBEDDED;
8224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8225 opts_type = OPTS_TYPE_PT_GENERATE_BE
8226 | OPTS_TYPE_PT_UNICODE
8227 | OPTS_TYPE_ST_ADD80
8228 | OPTS_TYPE_ST_ADDBITS15
8229 | OPTS_TYPE_ST_HEX;
8230 kern_type = KERN_TYPE_SHA512_PWSLTU;
8231 dgst_size = DGST_SIZE_8_8;
8232 parse_func = mssql2012_parse_hash;
8233 sort_by_digest = sort_by_digest_8_8;
8234 opti_type = OPTI_TYPE_ZERO_BYTE
8235 | OPTI_TYPE_PRECOMPUTE_INIT
8236 | OPTI_TYPE_PRECOMPUTE_MERKLE
8237 | OPTI_TYPE_EARLY_SKIP
8238 | OPTI_TYPE_NOT_ITERATED
8239 | OPTI_TYPE_APPENDED_SALT
8240 | OPTI_TYPE_USES_BITS_64
8241 | OPTI_TYPE_RAW_HASH;
8242 dgst_pos0 = 14;
8243 dgst_pos1 = 15;
8244 dgst_pos2 = 6;
8245 dgst_pos3 = 7;
8246 break;
8247
8248 case 1740: hash_type = HASH_TYPE_SHA512;
8249 salt_type = SALT_TYPE_INTERN;
8250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8251 opts_type = OPTS_TYPE_PT_GENERATE_BE
8252 | OPTS_TYPE_PT_ADD80
8253 | OPTS_TYPE_PT_ADDBITS15
8254 | OPTS_TYPE_PT_UNICODE;
8255 kern_type = KERN_TYPE_SHA512_SLTPWU;
8256 dgst_size = DGST_SIZE_8_8;
8257 parse_func = sha512s_parse_hash;
8258 sort_by_digest = sort_by_digest_8_8;
8259 opti_type = OPTI_TYPE_ZERO_BYTE
8260 | OPTI_TYPE_PRECOMPUTE_INIT
8261 | OPTI_TYPE_PRECOMPUTE_MERKLE
8262 | OPTI_TYPE_EARLY_SKIP
8263 | OPTI_TYPE_NOT_ITERATED
8264 | OPTI_TYPE_PREPENDED_SALT
8265 | OPTI_TYPE_USES_BITS_64
8266 | OPTI_TYPE_RAW_HASH;
8267 dgst_pos0 = 14;
8268 dgst_pos1 = 15;
8269 dgst_pos2 = 6;
8270 dgst_pos3 = 7;
8271 break;
8272
8273 case 1750: hash_type = HASH_TYPE_SHA512;
8274 salt_type = SALT_TYPE_INTERN;
8275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8276 opts_type = OPTS_TYPE_PT_GENERATE_BE
8277 | OPTS_TYPE_ST_ADD80;
8278 kern_type = KERN_TYPE_HMACSHA512_PW;
8279 dgst_size = DGST_SIZE_8_8;
8280 parse_func = hmacsha512_parse_hash;
8281 sort_by_digest = sort_by_digest_8_8;
8282 opti_type = OPTI_TYPE_ZERO_BYTE
8283 | OPTI_TYPE_USES_BITS_64
8284 | OPTI_TYPE_NOT_ITERATED;
8285 dgst_pos0 = 14;
8286 dgst_pos1 = 15;
8287 dgst_pos2 = 6;
8288 dgst_pos3 = 7;
8289 break;
8290
8291 case 1760: hash_type = HASH_TYPE_SHA512;
8292 salt_type = SALT_TYPE_INTERN;
8293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8294 opts_type = OPTS_TYPE_PT_GENERATE_BE
8295 | OPTS_TYPE_PT_ADD80
8296 | OPTS_TYPE_PT_ADDBITS15;
8297 kern_type = KERN_TYPE_HMACSHA512_SLT;
8298 dgst_size = DGST_SIZE_8_8;
8299 parse_func = hmacsha512_parse_hash;
8300 sort_by_digest = sort_by_digest_8_8;
8301 opti_type = OPTI_TYPE_ZERO_BYTE
8302 | OPTI_TYPE_USES_BITS_64
8303 | OPTI_TYPE_NOT_ITERATED;
8304 dgst_pos0 = 14;
8305 dgst_pos1 = 15;
8306 dgst_pos2 = 6;
8307 dgst_pos3 = 7;
8308 break;
8309
8310 case 1800: hash_type = HASH_TYPE_SHA512;
8311 salt_type = SALT_TYPE_EMBEDDED;
8312 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8313 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8314 kern_type = KERN_TYPE_SHA512CRYPT;
8315 dgst_size = DGST_SIZE_8_8;
8316 parse_func = sha512crypt_parse_hash;
8317 sort_by_digest = sort_by_digest_8_8;
8318 opti_type = OPTI_TYPE_ZERO_BYTE
8319 | OPTI_TYPE_USES_BITS_64;
8320 dgst_pos0 = 0;
8321 dgst_pos1 = 1;
8322 dgst_pos2 = 2;
8323 dgst_pos3 = 3;
8324 break;
8325
8326 case 2100: hash_type = HASH_TYPE_DCC2;
8327 salt_type = SALT_TYPE_EMBEDDED;
8328 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8329 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8330 | OPTS_TYPE_ST_LOWER
8331 | OPTS_TYPE_ST_UNICODE;
8332 kern_type = KERN_TYPE_DCC2;
8333 dgst_size = DGST_SIZE_4_4;
8334 parse_func = dcc2_parse_hash;
8335 sort_by_digest = sort_by_digest_4_4;
8336 opti_type = OPTI_TYPE_ZERO_BYTE;
8337 dgst_pos0 = 0;
8338 dgst_pos1 = 1;
8339 dgst_pos2 = 2;
8340 dgst_pos3 = 3;
8341 break;
8342
8343 case 2400: hash_type = HASH_TYPE_MD5;
8344 salt_type = SALT_TYPE_NONE;
8345 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8346 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8347 kern_type = KERN_TYPE_MD5PIX;
8348 dgst_size = DGST_SIZE_4_4;
8349 parse_func = md5pix_parse_hash;
8350 sort_by_digest = sort_by_digest_4_4;
8351 opti_type = OPTI_TYPE_ZERO_BYTE
8352 | OPTI_TYPE_PRECOMPUTE_INIT
8353 | OPTI_TYPE_PRECOMPUTE_MERKLE
8354 | OPTI_TYPE_EARLY_SKIP
8355 | OPTI_TYPE_NOT_ITERATED
8356 | OPTI_TYPE_NOT_SALTED;
8357 dgst_pos0 = 0;
8358 dgst_pos1 = 3;
8359 dgst_pos2 = 2;
8360 dgst_pos3 = 1;
8361 break;
8362
8363 case 2410: hash_type = HASH_TYPE_MD5;
8364 salt_type = SALT_TYPE_INTERN;
8365 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8366 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8367 kern_type = KERN_TYPE_MD5ASA;
8368 dgst_size = DGST_SIZE_4_4;
8369 parse_func = md5asa_parse_hash;
8370 sort_by_digest = sort_by_digest_4_4;
8371 opti_type = OPTI_TYPE_ZERO_BYTE
8372 | OPTI_TYPE_PRECOMPUTE_INIT
8373 | OPTI_TYPE_PRECOMPUTE_MERKLE
8374 | OPTI_TYPE_EARLY_SKIP
8375 | OPTI_TYPE_NOT_ITERATED;
8376 dgst_pos0 = 0;
8377 dgst_pos1 = 3;
8378 dgst_pos2 = 2;
8379 dgst_pos3 = 1;
8380 break;
8381
8382 case 2500: hash_type = HASH_TYPE_WPA;
8383 salt_type = SALT_TYPE_EMBEDDED;
8384 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8385 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8386 kern_type = KERN_TYPE_WPA;
8387 dgst_size = DGST_SIZE_4_4;
8388 parse_func = wpa_parse_hash;
8389 sort_by_digest = sort_by_digest_4_4;
8390 opti_type = OPTI_TYPE_ZERO_BYTE;
8391 dgst_pos0 = 0;
8392 dgst_pos1 = 1;
8393 dgst_pos2 = 2;
8394 dgst_pos3 = 3;
8395 break;
8396
8397 case 2600: hash_type = HASH_TYPE_MD5;
8398 salt_type = SALT_TYPE_VIRTUAL;
8399 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8400 opts_type = OPTS_TYPE_PT_GENERATE_LE
8401 | OPTS_TYPE_PT_ADD80
8402 | OPTS_TYPE_PT_ADDBITS14
8403 | OPTS_TYPE_ST_ADD80;
8404 kern_type = KERN_TYPE_MD55_PWSLT1;
8405 dgst_size = DGST_SIZE_4_4;
8406 parse_func = md5md5_parse_hash;
8407 sort_by_digest = sort_by_digest_4_4;
8408 opti_type = OPTI_TYPE_ZERO_BYTE
8409 | OPTI_TYPE_PRECOMPUTE_INIT
8410 | OPTI_TYPE_PRECOMPUTE_MERKLE
8411 | OPTI_TYPE_EARLY_SKIP;
8412 dgst_pos0 = 0;
8413 dgst_pos1 = 3;
8414 dgst_pos2 = 2;
8415 dgst_pos3 = 1;
8416 break;
8417
8418 case 2611: hash_type = HASH_TYPE_MD5;
8419 salt_type = SALT_TYPE_INTERN;
8420 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8421 opts_type = OPTS_TYPE_PT_GENERATE_LE
8422 | OPTS_TYPE_PT_ADD80
8423 | OPTS_TYPE_PT_ADDBITS14
8424 | OPTS_TYPE_ST_ADD80;
8425 kern_type = KERN_TYPE_MD55_PWSLT1;
8426 dgst_size = DGST_SIZE_4_4;
8427 parse_func = vb3_parse_hash;
8428 sort_by_digest = sort_by_digest_4_4;
8429 opti_type = OPTI_TYPE_ZERO_BYTE
8430 | OPTI_TYPE_PRECOMPUTE_INIT
8431 | OPTI_TYPE_PRECOMPUTE_MERKLE
8432 | OPTI_TYPE_EARLY_SKIP;
8433 dgst_pos0 = 0;
8434 dgst_pos1 = 3;
8435 dgst_pos2 = 2;
8436 dgst_pos3 = 1;
8437 break;
8438
8439 case 2612: hash_type = HASH_TYPE_MD5;
8440 salt_type = SALT_TYPE_EMBEDDED;
8441 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8442 opts_type = OPTS_TYPE_PT_GENERATE_LE
8443 | OPTS_TYPE_PT_ADD80
8444 | OPTS_TYPE_PT_ADDBITS14
8445 | OPTS_TYPE_ST_ADD80
8446 | OPTS_TYPE_ST_HEX;
8447 kern_type = KERN_TYPE_MD55_PWSLT1;
8448 dgst_size = DGST_SIZE_4_4;
8449 parse_func = phps_parse_hash;
8450 sort_by_digest = sort_by_digest_4_4;
8451 opti_type = OPTI_TYPE_ZERO_BYTE
8452 | OPTI_TYPE_PRECOMPUTE_INIT
8453 | OPTI_TYPE_PRECOMPUTE_MERKLE
8454 | OPTI_TYPE_EARLY_SKIP;
8455 dgst_pos0 = 0;
8456 dgst_pos1 = 3;
8457 dgst_pos2 = 2;
8458 dgst_pos3 = 1;
8459 break;
8460
8461 case 2711: hash_type = HASH_TYPE_MD5;
8462 salt_type = SALT_TYPE_INTERN;
8463 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8464 opts_type = OPTS_TYPE_PT_GENERATE_LE
8465 | OPTS_TYPE_PT_ADD80
8466 | OPTS_TYPE_PT_ADDBITS14
8467 | OPTS_TYPE_ST_ADD80;
8468 kern_type = KERN_TYPE_MD55_PWSLT2;
8469 dgst_size = DGST_SIZE_4_4;
8470 parse_func = vb30_parse_hash;
8471 sort_by_digest = sort_by_digest_4_4;
8472 opti_type = OPTI_TYPE_ZERO_BYTE
8473 | OPTI_TYPE_PRECOMPUTE_INIT
8474 | OPTI_TYPE_EARLY_SKIP;
8475 dgst_pos0 = 0;
8476 dgst_pos1 = 3;
8477 dgst_pos2 = 2;
8478 dgst_pos3 = 1;
8479 break;
8480
8481 case 2811: hash_type = HASH_TYPE_MD5;
8482 salt_type = SALT_TYPE_INTERN;
8483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8484 opts_type = OPTS_TYPE_PT_GENERATE_LE
8485 | OPTS_TYPE_PT_ADD80
8486 | OPTS_TYPE_PT_ADDBITS14;
8487 kern_type = KERN_TYPE_MD55_SLTPW;
8488 dgst_size = DGST_SIZE_4_4;
8489 parse_func = ipb2_parse_hash;
8490 sort_by_digest = sort_by_digest_4_4;
8491 opti_type = OPTI_TYPE_ZERO_BYTE
8492 | OPTI_TYPE_PRECOMPUTE_INIT
8493 | OPTI_TYPE_EARLY_SKIP;
8494 dgst_pos0 = 0;
8495 dgst_pos1 = 3;
8496 dgst_pos2 = 2;
8497 dgst_pos3 = 1;
8498 break;
8499
8500 case 3000: hash_type = HASH_TYPE_LM;
8501 salt_type = SALT_TYPE_NONE;
8502 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8503 opts_type = OPTS_TYPE_PT_GENERATE_LE
8504 | OPTS_TYPE_PT_UPPER
8505 | OPTS_TYPE_PT_BITSLICE;
8506 kern_type = KERN_TYPE_LM;
8507 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8508 parse_func = lm_parse_hash;
8509 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8510 opti_type = OPTI_TYPE_ZERO_BYTE
8511 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8512 dgst_pos0 = 0;
8513 dgst_pos1 = 1;
8514 dgst_pos2 = 2;
8515 dgst_pos3 = 3;
8516 break;
8517
8518 case 3100: hash_type = HASH_TYPE_ORACLEH;
8519 salt_type = SALT_TYPE_INTERN;
8520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8521 opts_type = OPTS_TYPE_PT_GENERATE_LE
8522 | OPTS_TYPE_PT_UPPER
8523 | OPTS_TYPE_ST_UPPER;
8524 kern_type = KERN_TYPE_ORACLEH;
8525 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8526 parse_func = oracleh_parse_hash;
8527 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8528 opti_type = OPTI_TYPE_ZERO_BYTE;
8529 dgst_pos0 = 0;
8530 dgst_pos1 = 1;
8531 dgst_pos2 = 2;
8532 dgst_pos3 = 3;
8533 break;
8534
8535 case 3200: hash_type = HASH_TYPE_BCRYPT;
8536 salt_type = SALT_TYPE_EMBEDDED;
8537 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8538 opts_type = OPTS_TYPE_PT_GENERATE_LE
8539 | OPTS_TYPE_ST_GENERATE_LE;
8540 kern_type = KERN_TYPE_BCRYPT;
8541 dgst_size = DGST_SIZE_4_6;
8542 parse_func = bcrypt_parse_hash;
8543 sort_by_digest = sort_by_digest_4_6;
8544 opti_type = OPTI_TYPE_ZERO_BYTE;
8545 dgst_pos0 = 0;
8546 dgst_pos1 = 1;
8547 dgst_pos2 = 2;
8548 dgst_pos3 = 3;
8549 break;
8550
8551 case 3710: hash_type = HASH_TYPE_MD5;
8552 salt_type = SALT_TYPE_INTERN;
8553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8554 opts_type = OPTS_TYPE_PT_GENERATE_LE
8555 | OPTS_TYPE_PT_ADD80
8556 | OPTS_TYPE_PT_ADDBITS14;
8557 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8558 dgst_size = DGST_SIZE_4_4;
8559 parse_func = md5s_parse_hash;
8560 sort_by_digest = sort_by_digest_4_4;
8561 opti_type = OPTI_TYPE_ZERO_BYTE
8562 | OPTI_TYPE_PRECOMPUTE_INIT
8563 | OPTI_TYPE_PRECOMPUTE_MERKLE
8564 | OPTI_TYPE_EARLY_SKIP;
8565 dgst_pos0 = 0;
8566 dgst_pos1 = 3;
8567 dgst_pos2 = 2;
8568 dgst_pos3 = 1;
8569 break;
8570
8571 case 3711: hash_type = HASH_TYPE_MD5;
8572 salt_type = SALT_TYPE_EMBEDDED;
8573 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8574 opts_type = OPTS_TYPE_PT_GENERATE_LE
8575 | OPTS_TYPE_PT_ADD80
8576 | OPTS_TYPE_PT_ADDBITS14;
8577 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8578 dgst_size = DGST_SIZE_4_4;
8579 parse_func = mediawiki_b_parse_hash;
8580 sort_by_digest = sort_by_digest_4_4;
8581 opti_type = OPTI_TYPE_ZERO_BYTE
8582 | OPTI_TYPE_PRECOMPUTE_INIT
8583 | OPTI_TYPE_PRECOMPUTE_MERKLE
8584 | OPTI_TYPE_EARLY_SKIP;
8585 dgst_pos0 = 0;
8586 dgst_pos1 = 3;
8587 dgst_pos2 = 2;
8588 dgst_pos3 = 1;
8589 break;
8590
8591 case 3800: hash_type = HASH_TYPE_MD5;
8592 salt_type = SALT_TYPE_INTERN;
8593 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8594 opts_type = OPTS_TYPE_PT_GENERATE_LE
8595 | OPTS_TYPE_ST_ADDBITS14;
8596 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8597 dgst_size = DGST_SIZE_4_4;
8598 parse_func = md5s_parse_hash;
8599 sort_by_digest = sort_by_digest_4_4;
8600 opti_type = OPTI_TYPE_ZERO_BYTE
8601 | OPTI_TYPE_PRECOMPUTE_INIT
8602 | OPTI_TYPE_PRECOMPUTE_MERKLE
8603 | OPTI_TYPE_EARLY_SKIP
8604 | OPTI_TYPE_NOT_ITERATED
8605 | OPTI_TYPE_RAW_HASH;
8606 dgst_pos0 = 0;
8607 dgst_pos1 = 3;
8608 dgst_pos2 = 2;
8609 dgst_pos3 = 1;
8610 break;
8611
8612 case 4300: hash_type = HASH_TYPE_MD5;
8613 salt_type = SALT_TYPE_VIRTUAL;
8614 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8615 opts_type = OPTS_TYPE_PT_GENERATE_LE
8616 | OPTS_TYPE_PT_ADD80
8617 | OPTS_TYPE_PT_ADDBITS14
8618 | OPTS_TYPE_ST_ADD80;
8619 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8620 dgst_size = DGST_SIZE_4_4;
8621 parse_func = md5md5_parse_hash;
8622 sort_by_digest = sort_by_digest_4_4;
8623 opti_type = OPTI_TYPE_ZERO_BYTE
8624 | OPTI_TYPE_PRECOMPUTE_INIT
8625 | OPTI_TYPE_PRECOMPUTE_MERKLE
8626 | OPTI_TYPE_EARLY_SKIP;
8627 dgst_pos0 = 0;
8628 dgst_pos1 = 3;
8629 dgst_pos2 = 2;
8630 dgst_pos3 = 1;
8631 break;
8632
8633
8634 case 4400: hash_type = HASH_TYPE_MD5;
8635 salt_type = SALT_TYPE_NONE;
8636 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8637 opts_type = OPTS_TYPE_PT_GENERATE_BE
8638 | OPTS_TYPE_PT_ADD80
8639 | OPTS_TYPE_PT_ADDBITS15;
8640 kern_type = KERN_TYPE_MD5_SHA1;
8641 dgst_size = DGST_SIZE_4_4;
8642 parse_func = md5_parse_hash;
8643 sort_by_digest = sort_by_digest_4_4;
8644 opti_type = OPTI_TYPE_ZERO_BYTE
8645 | OPTI_TYPE_PRECOMPUTE_INIT
8646 | OPTI_TYPE_PRECOMPUTE_MERKLE
8647 | OPTI_TYPE_EARLY_SKIP
8648 | OPTI_TYPE_NOT_ITERATED
8649 | OPTI_TYPE_NOT_SALTED
8650 | OPTI_TYPE_RAW_HASH;
8651 dgst_pos0 = 0;
8652 dgst_pos1 = 3;
8653 dgst_pos2 = 2;
8654 dgst_pos3 = 1;
8655 break;
8656
8657 case 4500: hash_type = HASH_TYPE_SHA1;
8658 salt_type = SALT_TYPE_NONE;
8659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8660 opts_type = OPTS_TYPE_PT_GENERATE_BE
8661 | OPTS_TYPE_PT_ADD80
8662 | OPTS_TYPE_PT_ADDBITS15;
8663 kern_type = KERN_TYPE_SHA11;
8664 dgst_size = DGST_SIZE_4_5;
8665 parse_func = sha1_parse_hash;
8666 sort_by_digest = sort_by_digest_4_5;
8667 opti_type = OPTI_TYPE_ZERO_BYTE
8668 | OPTI_TYPE_PRECOMPUTE_INIT
8669 | OPTI_TYPE_PRECOMPUTE_MERKLE
8670 | OPTI_TYPE_EARLY_SKIP
8671 | OPTI_TYPE_NOT_SALTED;
8672 dgst_pos0 = 3;
8673 dgst_pos1 = 4;
8674 dgst_pos2 = 2;
8675 dgst_pos3 = 1;
8676 break;
8677
8678 case 4700: hash_type = HASH_TYPE_SHA1;
8679 salt_type = SALT_TYPE_NONE;
8680 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8681 opts_type = OPTS_TYPE_PT_GENERATE_LE
8682 | OPTS_TYPE_PT_ADD80
8683 | OPTS_TYPE_PT_ADDBITS14;
8684 kern_type = KERN_TYPE_SHA1_MD5;
8685 dgst_size = DGST_SIZE_4_5;
8686 parse_func = sha1_parse_hash;
8687 sort_by_digest = sort_by_digest_4_5;
8688 opti_type = OPTI_TYPE_ZERO_BYTE
8689 | OPTI_TYPE_PRECOMPUTE_INIT
8690 | OPTI_TYPE_PRECOMPUTE_MERKLE
8691 | OPTI_TYPE_EARLY_SKIP
8692 | OPTI_TYPE_NOT_ITERATED
8693 | OPTI_TYPE_NOT_SALTED
8694 | OPTI_TYPE_RAW_HASH;
8695 dgst_pos0 = 3;
8696 dgst_pos1 = 4;
8697 dgst_pos2 = 2;
8698 dgst_pos3 = 1;
8699 break;
8700
8701 case 4800: hash_type = HASH_TYPE_MD5;
8702 salt_type = SALT_TYPE_EMBEDDED;
8703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8704 opts_type = OPTS_TYPE_PT_GENERATE_LE
8705 | OPTS_TYPE_PT_ADDBITS14;
8706 kern_type = KERN_TYPE_MD5_CHAP;
8707 dgst_size = DGST_SIZE_4_4;
8708 parse_func = chap_parse_hash;
8709 sort_by_digest = sort_by_digest_4_4;
8710 opti_type = OPTI_TYPE_ZERO_BYTE
8711 | OPTI_TYPE_PRECOMPUTE_INIT
8712 | OPTI_TYPE_PRECOMPUTE_MERKLE
8713 | OPTI_TYPE_MEET_IN_MIDDLE
8714 | OPTI_TYPE_EARLY_SKIP
8715 | OPTI_TYPE_NOT_ITERATED
8716 | OPTI_TYPE_RAW_HASH;
8717 dgst_pos0 = 0;
8718 dgst_pos1 = 3;
8719 dgst_pos2 = 2;
8720 dgst_pos3 = 1;
8721 break;
8722
8723 case 4900: hash_type = HASH_TYPE_SHA1;
8724 salt_type = SALT_TYPE_INTERN;
8725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8726 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8727 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8728 dgst_size = DGST_SIZE_4_5;
8729 parse_func = sha1s_parse_hash;
8730 sort_by_digest = sort_by_digest_4_5;
8731 opti_type = OPTI_TYPE_ZERO_BYTE
8732 | OPTI_TYPE_PRECOMPUTE_INIT
8733 | OPTI_TYPE_PRECOMPUTE_MERKLE
8734 | OPTI_TYPE_EARLY_SKIP;
8735 dgst_pos0 = 3;
8736 dgst_pos1 = 4;
8737 dgst_pos2 = 2;
8738 dgst_pos3 = 1;
8739 break;
8740
8741 case 5000: hash_type = HASH_TYPE_KECCAK;
8742 salt_type = SALT_TYPE_EMBEDDED;
8743 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8744 opts_type = OPTS_TYPE_PT_GENERATE_LE
8745 | OPTS_TYPE_PT_ADD01;
8746 kern_type = KERN_TYPE_KECCAK;
8747 dgst_size = DGST_SIZE_8_25;
8748 parse_func = keccak_parse_hash;
8749 sort_by_digest = sort_by_digest_8_25;
8750 opti_type = OPTI_TYPE_ZERO_BYTE
8751 | OPTI_TYPE_USES_BITS_64
8752 | OPTI_TYPE_RAW_HASH;
8753 dgst_pos0 = 2;
8754 dgst_pos1 = 3;
8755 dgst_pos2 = 4;
8756 dgst_pos3 = 5;
8757 break;
8758
8759 case 5100: hash_type = HASH_TYPE_MD5H;
8760 salt_type = SALT_TYPE_NONE;
8761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8762 opts_type = OPTS_TYPE_PT_GENERATE_LE
8763 | OPTS_TYPE_PT_ADD80
8764 | OPTS_TYPE_PT_ADDBITS14;
8765 kern_type = KERN_TYPE_MD5H;
8766 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8767 parse_func = md5half_parse_hash;
8768 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8769 opti_type = OPTI_TYPE_ZERO_BYTE
8770 | OPTI_TYPE_RAW_HASH;
8771 dgst_pos0 = 0;
8772 dgst_pos1 = 1;
8773 dgst_pos2 = 2;
8774 dgst_pos3 = 3;
8775 break;
8776
8777 case 5200: hash_type = HASH_TYPE_SHA256;
8778 salt_type = SALT_TYPE_EMBEDDED;
8779 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8780 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8781 kern_type = KERN_TYPE_PSAFE3;
8782 dgst_size = DGST_SIZE_4_8;
8783 parse_func = psafe3_parse_hash;
8784 sort_by_digest = sort_by_digest_4_8;
8785 opti_type = OPTI_TYPE_ZERO_BYTE;
8786 dgst_pos0 = 0;
8787 dgst_pos1 = 1;
8788 dgst_pos2 = 2;
8789 dgst_pos3 = 3;
8790 break;
8791
8792 case 5300: hash_type = HASH_TYPE_MD5;
8793 salt_type = SALT_TYPE_EMBEDDED;
8794 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8795 opts_type = OPTS_TYPE_PT_GENERATE_LE
8796 | OPTS_TYPE_ST_ADD80;
8797 kern_type = KERN_TYPE_IKEPSK_MD5;
8798 dgst_size = DGST_SIZE_4_4;
8799 parse_func = ikepsk_md5_parse_hash;
8800 sort_by_digest = sort_by_digest_4_4;
8801 opti_type = OPTI_TYPE_ZERO_BYTE;
8802 dgst_pos0 = 0;
8803 dgst_pos1 = 3;
8804 dgst_pos2 = 2;
8805 dgst_pos3 = 1;
8806 break;
8807
8808 case 5400: hash_type = HASH_TYPE_SHA1;
8809 salt_type = SALT_TYPE_EMBEDDED;
8810 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8811 opts_type = OPTS_TYPE_PT_GENERATE_BE
8812 | OPTS_TYPE_ST_ADD80;
8813 kern_type = KERN_TYPE_IKEPSK_SHA1;
8814 dgst_size = DGST_SIZE_4_5;
8815 parse_func = ikepsk_sha1_parse_hash;
8816 sort_by_digest = sort_by_digest_4_5;
8817 opti_type = OPTI_TYPE_ZERO_BYTE;
8818 dgst_pos0 = 3;
8819 dgst_pos1 = 4;
8820 dgst_pos2 = 2;
8821 dgst_pos3 = 1;
8822 break;
8823
8824 case 5500: hash_type = HASH_TYPE_NETNTLM;
8825 salt_type = SALT_TYPE_EMBEDDED;
8826 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8827 opts_type = OPTS_TYPE_PT_GENERATE_LE
8828 | OPTS_TYPE_PT_ADD80
8829 | OPTS_TYPE_PT_ADDBITS14
8830 | OPTS_TYPE_PT_UNICODE
8831 | OPTS_TYPE_ST_HEX;
8832 kern_type = KERN_TYPE_NETNTLMv1;
8833 dgst_size = DGST_SIZE_4_4;
8834 parse_func = netntlmv1_parse_hash;
8835 sort_by_digest = sort_by_digest_4_4;
8836 opti_type = OPTI_TYPE_ZERO_BYTE
8837 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8838 dgst_pos0 = 0;
8839 dgst_pos1 = 1;
8840 dgst_pos2 = 2;
8841 dgst_pos3 = 3;
8842 break;
8843
8844 case 5600: hash_type = HASH_TYPE_MD5;
8845 salt_type = SALT_TYPE_EMBEDDED;
8846 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8847 opts_type = OPTS_TYPE_PT_GENERATE_LE
8848 | OPTS_TYPE_PT_ADD80
8849 | OPTS_TYPE_PT_ADDBITS14
8850 | OPTS_TYPE_PT_UNICODE;
8851 kern_type = KERN_TYPE_NETNTLMv2;
8852 dgst_size = DGST_SIZE_4_4;
8853 parse_func = netntlmv2_parse_hash;
8854 sort_by_digest = sort_by_digest_4_4;
8855 opti_type = OPTI_TYPE_ZERO_BYTE;
8856 dgst_pos0 = 0;
8857 dgst_pos1 = 3;
8858 dgst_pos2 = 2;
8859 dgst_pos3 = 1;
8860 break;
8861
8862 case 5700: hash_type = HASH_TYPE_SHA256;
8863 salt_type = SALT_TYPE_NONE;
8864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8865 opts_type = OPTS_TYPE_PT_GENERATE_BE
8866 | OPTS_TYPE_PT_ADD80
8867 | OPTS_TYPE_PT_ADDBITS15;
8868 kern_type = KERN_TYPE_SHA256;
8869 dgst_size = DGST_SIZE_4_8;
8870 parse_func = cisco4_parse_hash;
8871 sort_by_digest = sort_by_digest_4_8;
8872 opti_type = OPTI_TYPE_ZERO_BYTE
8873 | OPTI_TYPE_PRECOMPUTE_INIT
8874 | OPTI_TYPE_PRECOMPUTE_MERKLE
8875 | OPTI_TYPE_EARLY_SKIP
8876 | OPTI_TYPE_NOT_ITERATED
8877 | OPTI_TYPE_NOT_SALTED
8878 | OPTI_TYPE_RAW_HASH;
8879 dgst_pos0 = 3;
8880 dgst_pos1 = 7;
8881 dgst_pos2 = 2;
8882 dgst_pos3 = 6;
8883 break;
8884
8885 case 5800: hash_type = HASH_TYPE_SHA1;
8886 salt_type = SALT_TYPE_INTERN;
8887 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8888 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8889 | OPTS_TYPE_ST_ADD80;
8890 kern_type = KERN_TYPE_ANDROIDPIN;
8891 dgst_size = DGST_SIZE_4_5;
8892 parse_func = androidpin_parse_hash;
8893 sort_by_digest = sort_by_digest_4_5;
8894 opti_type = OPTI_TYPE_ZERO_BYTE;
8895 dgst_pos0 = 0;
8896 dgst_pos1 = 1;
8897 dgst_pos2 = 2;
8898 dgst_pos3 = 3;
8899 break;
8900
8901 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8902 salt_type = SALT_TYPE_NONE;
8903 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8904 opts_type = OPTS_TYPE_PT_GENERATE_LE
8905 | OPTS_TYPE_PT_ADD80;
8906 kern_type = KERN_TYPE_RIPEMD160;
8907 dgst_size = DGST_SIZE_4_5;
8908 parse_func = ripemd160_parse_hash;
8909 sort_by_digest = sort_by_digest_4_5;
8910 opti_type = OPTI_TYPE_ZERO_BYTE;
8911 dgst_pos0 = 0;
8912 dgst_pos1 = 1;
8913 dgst_pos2 = 2;
8914 dgst_pos3 = 3;
8915 break;
8916
8917 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8918 salt_type = SALT_TYPE_NONE;
8919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8920 opts_type = OPTS_TYPE_PT_GENERATE_BE
8921 | OPTS_TYPE_PT_ADD80;
8922 kern_type = KERN_TYPE_WHIRLPOOL;
8923 dgst_size = DGST_SIZE_4_16;
8924 parse_func = whirlpool_parse_hash;
8925 sort_by_digest = sort_by_digest_4_16;
8926 opti_type = OPTI_TYPE_ZERO_BYTE;
8927 dgst_pos0 = 0;
8928 dgst_pos1 = 1;
8929 dgst_pos2 = 2;
8930 dgst_pos3 = 3;
8931 break;
8932
8933 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8934 salt_type = SALT_TYPE_EMBEDDED;
8935 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8936 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8937 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8938 dgst_size = DGST_SIZE_4_5;
8939 parse_func = truecrypt_parse_hash_2k;
8940 sort_by_digest = sort_by_digest_4_5;
8941 opti_type = OPTI_TYPE_ZERO_BYTE;
8942 dgst_pos0 = 0;
8943 dgst_pos1 = 1;
8944 dgst_pos2 = 2;
8945 dgst_pos3 = 3;
8946 break;
8947
8948 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8949 salt_type = SALT_TYPE_EMBEDDED;
8950 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8951 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8952 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8953 dgst_size = DGST_SIZE_4_5;
8954 parse_func = truecrypt_parse_hash_2k;
8955 sort_by_digest = sort_by_digest_4_5;
8956 opti_type = OPTI_TYPE_ZERO_BYTE;
8957 dgst_pos0 = 0;
8958 dgst_pos1 = 1;
8959 dgst_pos2 = 2;
8960 dgst_pos3 = 3;
8961 break;
8962
8963 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8964 salt_type = SALT_TYPE_EMBEDDED;
8965 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8966 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8967 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8968 dgst_size = DGST_SIZE_4_5;
8969 parse_func = truecrypt_parse_hash_2k;
8970 sort_by_digest = sort_by_digest_4_5;
8971 opti_type = OPTI_TYPE_ZERO_BYTE;
8972 dgst_pos0 = 0;
8973 dgst_pos1 = 1;
8974 dgst_pos2 = 2;
8975 dgst_pos3 = 3;
8976 break;
8977
8978 case 6221: hash_type = HASH_TYPE_SHA512;
8979 salt_type = SALT_TYPE_EMBEDDED;
8980 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8981 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8982 kern_type = KERN_TYPE_TCSHA512_XTS512;
8983 dgst_size = DGST_SIZE_8_8;
8984 parse_func = truecrypt_parse_hash_1k;
8985 sort_by_digest = sort_by_digest_8_8;
8986 opti_type = OPTI_TYPE_ZERO_BYTE
8987 | OPTI_TYPE_USES_BITS_64;
8988 dgst_pos0 = 0;
8989 dgst_pos1 = 1;
8990 dgst_pos2 = 2;
8991 dgst_pos3 = 3;
8992 break;
8993
8994 case 6222: hash_type = HASH_TYPE_SHA512;
8995 salt_type = SALT_TYPE_EMBEDDED;
8996 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8997 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8998 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8999 dgst_size = DGST_SIZE_8_8;
9000 parse_func = truecrypt_parse_hash_1k;
9001 sort_by_digest = sort_by_digest_8_8;
9002 opti_type = OPTI_TYPE_ZERO_BYTE
9003 | OPTI_TYPE_USES_BITS_64;
9004 dgst_pos0 = 0;
9005 dgst_pos1 = 1;
9006 dgst_pos2 = 2;
9007 dgst_pos3 = 3;
9008 break;
9009
9010 case 6223: hash_type = HASH_TYPE_SHA512;
9011 salt_type = SALT_TYPE_EMBEDDED;
9012 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9013 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9014 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9015 dgst_size = DGST_SIZE_8_8;
9016 parse_func = truecrypt_parse_hash_1k;
9017 sort_by_digest = sort_by_digest_8_8;
9018 opti_type = OPTI_TYPE_ZERO_BYTE
9019 | OPTI_TYPE_USES_BITS_64;
9020 dgst_pos0 = 0;
9021 dgst_pos1 = 1;
9022 dgst_pos2 = 2;
9023 dgst_pos3 = 3;
9024 break;
9025
9026 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9027 salt_type = SALT_TYPE_EMBEDDED;
9028 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9029 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9030 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9031 dgst_size = DGST_SIZE_4_8;
9032 parse_func = truecrypt_parse_hash_1k;
9033 sort_by_digest = sort_by_digest_4_8;
9034 opti_type = OPTI_TYPE_ZERO_BYTE;
9035 dgst_pos0 = 0;
9036 dgst_pos1 = 1;
9037 dgst_pos2 = 2;
9038 dgst_pos3 = 3;
9039 break;
9040
9041 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9042 salt_type = SALT_TYPE_EMBEDDED;
9043 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9044 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9045 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9046 dgst_size = DGST_SIZE_4_8;
9047 parse_func = truecrypt_parse_hash_1k;
9048 sort_by_digest = sort_by_digest_4_8;
9049 opti_type = OPTI_TYPE_ZERO_BYTE;
9050 dgst_pos0 = 0;
9051 dgst_pos1 = 1;
9052 dgst_pos2 = 2;
9053 dgst_pos3 = 3;
9054 break;
9055
9056 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9057 salt_type = SALT_TYPE_EMBEDDED;
9058 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9059 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9060 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9061 dgst_size = DGST_SIZE_4_8;
9062 parse_func = truecrypt_parse_hash_1k;
9063 sort_by_digest = sort_by_digest_4_8;
9064 opti_type = OPTI_TYPE_ZERO_BYTE;
9065 dgst_pos0 = 0;
9066 dgst_pos1 = 1;
9067 dgst_pos2 = 2;
9068 dgst_pos3 = 3;
9069 break;
9070
9071 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9072 salt_type = SALT_TYPE_EMBEDDED;
9073 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9074 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9075 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9076 dgst_size = DGST_SIZE_4_5;
9077 parse_func = truecrypt_parse_hash_1k;
9078 sort_by_digest = sort_by_digest_4_5;
9079 opti_type = OPTI_TYPE_ZERO_BYTE;
9080 dgst_pos0 = 0;
9081 dgst_pos1 = 1;
9082 dgst_pos2 = 2;
9083 dgst_pos3 = 3;
9084 break;
9085
9086 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9087 salt_type = SALT_TYPE_EMBEDDED;
9088 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9089 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9090 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9091 dgst_size = DGST_SIZE_4_5;
9092 parse_func = truecrypt_parse_hash_1k;
9093 sort_by_digest = sort_by_digest_4_5;
9094 opti_type = OPTI_TYPE_ZERO_BYTE;
9095 dgst_pos0 = 0;
9096 dgst_pos1 = 1;
9097 dgst_pos2 = 2;
9098 dgst_pos3 = 3;
9099 break;
9100
9101 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9102 salt_type = SALT_TYPE_EMBEDDED;
9103 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9104 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9105 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9106 dgst_size = DGST_SIZE_4_5;
9107 parse_func = truecrypt_parse_hash_1k;
9108 sort_by_digest = sort_by_digest_4_5;
9109 opti_type = OPTI_TYPE_ZERO_BYTE;
9110 dgst_pos0 = 0;
9111 dgst_pos1 = 1;
9112 dgst_pos2 = 2;
9113 dgst_pos3 = 3;
9114 break;
9115
9116 case 6300: hash_type = HASH_TYPE_MD5;
9117 salt_type = SALT_TYPE_EMBEDDED;
9118 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9119 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9120 kern_type = KERN_TYPE_MD5AIX;
9121 dgst_size = DGST_SIZE_4_4;
9122 parse_func = md5aix_parse_hash;
9123 sort_by_digest = sort_by_digest_4_4;
9124 opti_type = OPTI_TYPE_ZERO_BYTE;
9125 dgst_pos0 = 0;
9126 dgst_pos1 = 1;
9127 dgst_pos2 = 2;
9128 dgst_pos3 = 3;
9129 break;
9130
9131 case 6400: hash_type = HASH_TYPE_SHA256;
9132 salt_type = SALT_TYPE_EMBEDDED;
9133 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9134 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9135 kern_type = KERN_TYPE_SHA256AIX;
9136 dgst_size = DGST_SIZE_4_8;
9137 parse_func = sha256aix_parse_hash;
9138 sort_by_digest = sort_by_digest_4_8;
9139 opti_type = OPTI_TYPE_ZERO_BYTE;
9140 dgst_pos0 = 0;
9141 dgst_pos1 = 1;
9142 dgst_pos2 = 2;
9143 dgst_pos3 = 3;
9144 break;
9145
9146 case 6500: hash_type = HASH_TYPE_SHA512;
9147 salt_type = SALT_TYPE_EMBEDDED;
9148 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9149 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9150 kern_type = KERN_TYPE_SHA512AIX;
9151 dgst_size = DGST_SIZE_8_8;
9152 parse_func = sha512aix_parse_hash;
9153 sort_by_digest = sort_by_digest_8_8;
9154 opti_type = OPTI_TYPE_ZERO_BYTE
9155 | OPTI_TYPE_USES_BITS_64;
9156 dgst_pos0 = 0;
9157 dgst_pos1 = 1;
9158 dgst_pos2 = 2;
9159 dgst_pos3 = 3;
9160 break;
9161
9162 case 6600: hash_type = HASH_TYPE_AES;
9163 salt_type = SALT_TYPE_EMBEDDED;
9164 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9165 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9166 kern_type = KERN_TYPE_AGILEKEY;
9167 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9168 parse_func = agilekey_parse_hash;
9169 sort_by_digest = sort_by_digest_4_5;
9170 opti_type = OPTI_TYPE_ZERO_BYTE;
9171 dgst_pos0 = 0;
9172 dgst_pos1 = 1;
9173 dgst_pos2 = 2;
9174 dgst_pos3 = 3;
9175 break;
9176
9177 case 6700: hash_type = HASH_TYPE_SHA1;
9178 salt_type = SALT_TYPE_EMBEDDED;
9179 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9180 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9181 kern_type = KERN_TYPE_SHA1AIX;
9182 dgst_size = DGST_SIZE_4_5;
9183 parse_func = sha1aix_parse_hash;
9184 sort_by_digest = sort_by_digest_4_5;
9185 opti_type = OPTI_TYPE_ZERO_BYTE;
9186 dgst_pos0 = 0;
9187 dgst_pos1 = 1;
9188 dgst_pos2 = 2;
9189 dgst_pos3 = 3;
9190 break;
9191
9192 case 6800: hash_type = HASH_TYPE_AES;
9193 salt_type = SALT_TYPE_EMBEDDED;
9194 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9195 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9196 kern_type = KERN_TYPE_LASTPASS;
9197 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9198 parse_func = lastpass_parse_hash;
9199 sort_by_digest = sort_by_digest_4_8;
9200 opti_type = OPTI_TYPE_ZERO_BYTE;
9201 dgst_pos0 = 0;
9202 dgst_pos1 = 1;
9203 dgst_pos2 = 2;
9204 dgst_pos3 = 3;
9205 break;
9206
9207 case 6900: hash_type = HASH_TYPE_GOST;
9208 salt_type = SALT_TYPE_NONE;
9209 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9210 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9211 kern_type = KERN_TYPE_GOST;
9212 dgst_size = DGST_SIZE_4_8;
9213 parse_func = gost_parse_hash;
9214 sort_by_digest = sort_by_digest_4_8;
9215 opti_type = OPTI_TYPE_ZERO_BYTE;
9216 dgst_pos0 = 0;
9217 dgst_pos1 = 1;
9218 dgst_pos2 = 2;
9219 dgst_pos3 = 3;
9220 break;
9221
9222 case 7100: hash_type = HASH_TYPE_SHA512;
9223 salt_type = SALT_TYPE_EMBEDDED;
9224 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9225 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9226 kern_type = KERN_TYPE_PBKDF2_SHA512;
9227 dgst_size = DGST_SIZE_8_16;
9228 parse_func = sha512osx_parse_hash;
9229 sort_by_digest = sort_by_digest_8_16;
9230 opti_type = OPTI_TYPE_ZERO_BYTE
9231 | OPTI_TYPE_USES_BITS_64;
9232 dgst_pos0 = 0;
9233 dgst_pos1 = 1;
9234 dgst_pos2 = 2;
9235 dgst_pos3 = 3;
9236 break;
9237
9238 case 7200: hash_type = HASH_TYPE_SHA512;
9239 salt_type = SALT_TYPE_EMBEDDED;
9240 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9241 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9242 kern_type = KERN_TYPE_PBKDF2_SHA512;
9243 dgst_size = DGST_SIZE_8_16;
9244 parse_func = sha512grub_parse_hash;
9245 sort_by_digest = sort_by_digest_8_16;
9246 opti_type = OPTI_TYPE_ZERO_BYTE
9247 | OPTI_TYPE_USES_BITS_64;
9248 dgst_pos0 = 0;
9249 dgst_pos1 = 1;
9250 dgst_pos2 = 2;
9251 dgst_pos3 = 3;
9252 break;
9253
9254 case 7300: hash_type = HASH_TYPE_SHA1;
9255 salt_type = SALT_TYPE_EMBEDDED;
9256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9257 opts_type = OPTS_TYPE_PT_GENERATE_BE
9258 | OPTS_TYPE_ST_ADD80
9259 | OPTS_TYPE_ST_ADDBITS15;
9260 kern_type = KERN_TYPE_RAKP;
9261 dgst_size = DGST_SIZE_4_5;
9262 parse_func = rakp_parse_hash;
9263 sort_by_digest = sort_by_digest_4_5;
9264 opti_type = OPTI_TYPE_ZERO_BYTE
9265 | OPTI_TYPE_NOT_ITERATED;
9266 dgst_pos0 = 3;
9267 dgst_pos1 = 4;
9268 dgst_pos2 = 2;
9269 dgst_pos3 = 1;
9270 break;
9271
9272 case 7400: hash_type = HASH_TYPE_SHA256;
9273 salt_type = SALT_TYPE_EMBEDDED;
9274 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9275 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9276 kern_type = KERN_TYPE_SHA256CRYPT;
9277 dgst_size = DGST_SIZE_4_8;
9278 parse_func = sha256crypt_parse_hash;
9279 sort_by_digest = sort_by_digest_4_8;
9280 opti_type = OPTI_TYPE_ZERO_BYTE;
9281 dgst_pos0 = 0;
9282 dgst_pos1 = 1;
9283 dgst_pos2 = 2;
9284 dgst_pos3 = 3;
9285 break;
9286
9287 case 7500: hash_type = HASH_TYPE_KRB5PA;
9288 salt_type = SALT_TYPE_EMBEDDED;
9289 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9290 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9291 kern_type = KERN_TYPE_KRB5PA;
9292 dgst_size = DGST_SIZE_4_4;
9293 parse_func = krb5pa_parse_hash;
9294 sort_by_digest = sort_by_digest_4_4;
9295 opti_type = OPTI_TYPE_ZERO_BYTE
9296 | OPTI_TYPE_NOT_ITERATED;
9297 dgst_pos0 = 0;
9298 dgst_pos1 = 1;
9299 dgst_pos2 = 2;
9300 dgst_pos3 = 3;
9301 break;
9302
9303 case 7600: hash_type = HASH_TYPE_SHA1;
9304 salt_type = SALT_TYPE_INTERN;
9305 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9306 opts_type = OPTS_TYPE_PT_GENERATE_BE
9307 | OPTS_TYPE_PT_ADD80
9308 | OPTS_TYPE_PT_ADDBITS15;
9309 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9310 dgst_size = DGST_SIZE_4_5;
9311 parse_func = redmine_parse_hash;
9312 sort_by_digest = sort_by_digest_4_5;
9313 opti_type = OPTI_TYPE_ZERO_BYTE
9314 | OPTI_TYPE_PRECOMPUTE_INIT
9315 | OPTI_TYPE_EARLY_SKIP
9316 | OPTI_TYPE_NOT_ITERATED
9317 | OPTI_TYPE_PREPENDED_SALT;
9318 dgst_pos0 = 3;
9319 dgst_pos1 = 4;
9320 dgst_pos2 = 2;
9321 dgst_pos3 = 1;
9322 break;
9323
9324 case 7700: hash_type = HASH_TYPE_SAPB;
9325 salt_type = SALT_TYPE_EMBEDDED;
9326 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9327 opts_type = OPTS_TYPE_PT_GENERATE_LE
9328 | OPTS_TYPE_PT_UPPER
9329 | OPTS_TYPE_ST_UPPER;
9330 kern_type = KERN_TYPE_SAPB;
9331 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9332 parse_func = sapb_parse_hash;
9333 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9334 opti_type = OPTI_TYPE_ZERO_BYTE
9335 | OPTI_TYPE_PRECOMPUTE_INIT
9336 | OPTI_TYPE_NOT_ITERATED;
9337 dgst_pos0 = 0;
9338 dgst_pos1 = 1;
9339 dgst_pos2 = 2;
9340 dgst_pos3 = 3;
9341 break;
9342
9343 case 7800: hash_type = HASH_TYPE_SAPG;
9344 salt_type = SALT_TYPE_EMBEDDED;
9345 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9346 opts_type = OPTS_TYPE_PT_GENERATE_BE
9347 | OPTS_TYPE_ST_ADD80
9348 | OPTS_TYPE_ST_UPPER;
9349 kern_type = KERN_TYPE_SAPG;
9350 dgst_size = DGST_SIZE_4_5;
9351 parse_func = sapg_parse_hash;
9352 sort_by_digest = sort_by_digest_4_5;
9353 opti_type = OPTI_TYPE_ZERO_BYTE
9354 | OPTI_TYPE_PRECOMPUTE_INIT
9355 | OPTI_TYPE_NOT_ITERATED;
9356 dgst_pos0 = 3;
9357 dgst_pos1 = 4;
9358 dgst_pos2 = 2;
9359 dgst_pos3 = 1;
9360 break;
9361
9362 case 7900: hash_type = HASH_TYPE_SHA512;
9363 salt_type = SALT_TYPE_EMBEDDED;
9364 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9365 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9366 kern_type = KERN_TYPE_DRUPAL7;
9367 dgst_size = DGST_SIZE_8_8;
9368 parse_func = drupal7_parse_hash;
9369 sort_by_digest = sort_by_digest_8_8;
9370 opti_type = OPTI_TYPE_ZERO_BYTE
9371 | OPTI_TYPE_USES_BITS_64;
9372 dgst_pos0 = 0;
9373 dgst_pos1 = 1;
9374 dgst_pos2 = 2;
9375 dgst_pos3 = 3;
9376 break;
9377
9378 case 8000: hash_type = HASH_TYPE_SHA256;
9379 salt_type = SALT_TYPE_EMBEDDED;
9380 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9381 opts_type = OPTS_TYPE_PT_GENERATE_BE
9382 | OPTS_TYPE_PT_UNICODE
9383 | OPTS_TYPE_ST_ADD80
9384 | OPTS_TYPE_ST_HEX;
9385 kern_type = KERN_TYPE_SYBASEASE;
9386 dgst_size = DGST_SIZE_4_8;
9387 parse_func = sybasease_parse_hash;
9388 sort_by_digest = sort_by_digest_4_8;
9389 opti_type = OPTI_TYPE_ZERO_BYTE
9390 | OPTI_TYPE_PRECOMPUTE_INIT
9391 | OPTI_TYPE_EARLY_SKIP
9392 | OPTI_TYPE_NOT_ITERATED
9393 | OPTI_TYPE_RAW_HASH;
9394 dgst_pos0 = 3;
9395 dgst_pos1 = 7;
9396 dgst_pos2 = 2;
9397 dgst_pos3 = 6;
9398 break;
9399
9400 case 8100: hash_type = HASH_TYPE_SHA1;
9401 salt_type = SALT_TYPE_EMBEDDED;
9402 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9403 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9404 kern_type = KERN_TYPE_NETSCALER;
9405 dgst_size = DGST_SIZE_4_5;
9406 parse_func = netscaler_parse_hash;
9407 sort_by_digest = sort_by_digest_4_5;
9408 opti_type = OPTI_TYPE_ZERO_BYTE
9409 | OPTI_TYPE_PRECOMPUTE_INIT
9410 | OPTI_TYPE_PRECOMPUTE_MERKLE
9411 | OPTI_TYPE_EARLY_SKIP
9412 | OPTI_TYPE_NOT_ITERATED
9413 | OPTI_TYPE_PREPENDED_SALT
9414 | OPTI_TYPE_RAW_HASH;
9415 dgst_pos0 = 3;
9416 dgst_pos1 = 4;
9417 dgst_pos2 = 2;
9418 dgst_pos3 = 1;
9419 break;
9420
9421 case 8200: hash_type = HASH_TYPE_SHA256;
9422 salt_type = SALT_TYPE_EMBEDDED;
9423 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9424 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9425 kern_type = KERN_TYPE_CLOUDKEY;
9426 dgst_size = DGST_SIZE_4_8;
9427 parse_func = cloudkey_parse_hash;
9428 sort_by_digest = sort_by_digest_4_8;
9429 opti_type = OPTI_TYPE_ZERO_BYTE;
9430 dgst_pos0 = 0;
9431 dgst_pos1 = 1;
9432 dgst_pos2 = 2;
9433 dgst_pos3 = 3;
9434 break;
9435
9436 case 8300: hash_type = HASH_TYPE_SHA1;
9437 salt_type = SALT_TYPE_EMBEDDED;
9438 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9439 opts_type = OPTS_TYPE_PT_GENERATE_LE
9440 | OPTS_TYPE_ST_HEX
9441 | OPTS_TYPE_ST_ADD80;
9442 kern_type = KERN_TYPE_NSEC3;
9443 dgst_size = DGST_SIZE_4_5;
9444 parse_func = nsec3_parse_hash;
9445 sort_by_digest = sort_by_digest_4_5;
9446 opti_type = OPTI_TYPE_ZERO_BYTE;
9447 dgst_pos0 = 3;
9448 dgst_pos1 = 4;
9449 dgst_pos2 = 2;
9450 dgst_pos3 = 1;
9451 break;
9452
9453 case 8400: hash_type = HASH_TYPE_SHA1;
9454 salt_type = SALT_TYPE_INTERN;
9455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9456 opts_type = OPTS_TYPE_PT_GENERATE_BE
9457 | OPTS_TYPE_PT_ADD80
9458 | OPTS_TYPE_PT_ADDBITS15;
9459 kern_type = KERN_TYPE_WBB3;
9460 dgst_size = DGST_SIZE_4_5;
9461 parse_func = wbb3_parse_hash;
9462 sort_by_digest = sort_by_digest_4_5;
9463 opti_type = OPTI_TYPE_ZERO_BYTE
9464 | OPTI_TYPE_PRECOMPUTE_INIT
9465 | OPTI_TYPE_NOT_ITERATED;
9466 dgst_pos0 = 3;
9467 dgst_pos1 = 4;
9468 dgst_pos2 = 2;
9469 dgst_pos3 = 1;
9470 break;
9471
9472 case 8500: hash_type = HASH_TYPE_DESRACF;
9473 salt_type = SALT_TYPE_EMBEDDED;
9474 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9475 opts_type = OPTS_TYPE_PT_GENERATE_LE
9476 | OPTS_TYPE_ST_UPPER;
9477 kern_type = KERN_TYPE_RACF;
9478 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9479 parse_func = racf_parse_hash;
9480 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9481 opti_type = OPTI_TYPE_ZERO_BYTE
9482 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9483 dgst_pos0 = 0;
9484 dgst_pos1 = 1;
9485 dgst_pos2 = 2;
9486 dgst_pos3 = 3;
9487 break;
9488
9489 case 8600: hash_type = HASH_TYPE_LOTUS5;
9490 salt_type = SALT_TYPE_NONE;
9491 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9492 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9493 kern_type = KERN_TYPE_LOTUS5;
9494 dgst_size = DGST_SIZE_4_4;
9495 parse_func = lotus5_parse_hash;
9496 sort_by_digest = sort_by_digest_4_4;
9497 opti_type = OPTI_TYPE_EARLY_SKIP
9498 | OPTI_TYPE_NOT_ITERATED
9499 | OPTI_TYPE_NOT_SALTED
9500 | OPTI_TYPE_RAW_HASH;
9501 dgst_pos0 = 0;
9502 dgst_pos1 = 1;
9503 dgst_pos2 = 2;
9504 dgst_pos3 = 3;
9505 break;
9506
9507 case 8700: hash_type = HASH_TYPE_LOTUS6;
9508 salt_type = SALT_TYPE_EMBEDDED;
9509 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9510 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9511 kern_type = KERN_TYPE_LOTUS6;
9512 dgst_size = DGST_SIZE_4_4;
9513 parse_func = lotus6_parse_hash;
9514 sort_by_digest = sort_by_digest_4_4;
9515 opti_type = OPTI_TYPE_EARLY_SKIP
9516 | OPTI_TYPE_NOT_ITERATED
9517 | OPTI_TYPE_RAW_HASH;
9518 dgst_pos0 = 0;
9519 dgst_pos1 = 1;
9520 dgst_pos2 = 2;
9521 dgst_pos3 = 3;
9522 break;
9523
9524 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9525 salt_type = SALT_TYPE_EMBEDDED;
9526 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9527 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9528 kern_type = KERN_TYPE_ANDROIDFDE;
9529 dgst_size = DGST_SIZE_4_4;
9530 parse_func = androidfde_parse_hash;
9531 sort_by_digest = sort_by_digest_4_4;
9532 opti_type = OPTI_TYPE_ZERO_BYTE;
9533 dgst_pos0 = 0;
9534 dgst_pos1 = 1;
9535 dgst_pos2 = 2;
9536 dgst_pos3 = 3;
9537 break;
9538
9539 case 8900: hash_type = HASH_TYPE_SCRYPT;
9540 salt_type = SALT_TYPE_EMBEDDED;
9541 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9542 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9543 kern_type = KERN_TYPE_SCRYPT;
9544 dgst_size = DGST_SIZE_4_8;
9545 parse_func = scrypt_parse_hash;
9546 sort_by_digest = sort_by_digest_4_8;
9547 opti_type = OPTI_TYPE_ZERO_BYTE;
9548 dgst_pos0 = 0;
9549 dgst_pos1 = 1;
9550 dgst_pos2 = 2;
9551 dgst_pos3 = 3;
9552 break;
9553
9554 case 9000: hash_type = HASH_TYPE_SHA1;
9555 salt_type = SALT_TYPE_EMBEDDED;
9556 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9557 opts_type = OPTS_TYPE_PT_GENERATE_LE
9558 | OPTS_TYPE_ST_GENERATE_LE;
9559 kern_type = KERN_TYPE_PSAFE2;
9560 dgst_size = DGST_SIZE_4_5;
9561 parse_func = psafe2_parse_hash;
9562 sort_by_digest = sort_by_digest_4_5;
9563 opti_type = OPTI_TYPE_ZERO_BYTE;
9564 dgst_pos0 = 0;
9565 dgst_pos1 = 1;
9566 dgst_pos2 = 2;
9567 dgst_pos3 = 3;
9568 break;
9569
9570 case 9100: hash_type = HASH_TYPE_LOTUS8;
9571 salt_type = SALT_TYPE_EMBEDDED;
9572 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9573 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9574 kern_type = KERN_TYPE_LOTUS8;
9575 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9576 parse_func = lotus8_parse_hash;
9577 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9578 opti_type = OPTI_TYPE_ZERO_BYTE;
9579 dgst_pos0 = 0;
9580 dgst_pos1 = 1;
9581 dgst_pos2 = 2;
9582 dgst_pos3 = 3;
9583 break;
9584
9585 case 9200: hash_type = HASH_TYPE_SHA256;
9586 salt_type = SALT_TYPE_EMBEDDED;
9587 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9588 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9589 kern_type = KERN_TYPE_PBKDF2_SHA256;
9590 dgst_size = DGST_SIZE_4_32;
9591 parse_func = cisco8_parse_hash;
9592 sort_by_digest = sort_by_digest_4_32;
9593 opti_type = OPTI_TYPE_ZERO_BYTE;
9594 dgst_pos0 = 0;
9595 dgst_pos1 = 1;
9596 dgst_pos2 = 2;
9597 dgst_pos3 = 3;
9598 break;
9599
9600 case 9300: hash_type = HASH_TYPE_SCRYPT;
9601 salt_type = SALT_TYPE_EMBEDDED;
9602 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9603 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9604 kern_type = KERN_TYPE_SCRYPT;
9605 dgst_size = DGST_SIZE_4_8;
9606 parse_func = cisco9_parse_hash;
9607 sort_by_digest = sort_by_digest_4_8;
9608 opti_type = OPTI_TYPE_ZERO_BYTE;
9609 dgst_pos0 = 0;
9610 dgst_pos1 = 1;
9611 dgst_pos2 = 2;
9612 dgst_pos3 = 3;
9613 break;
9614
9615 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9616 salt_type = SALT_TYPE_EMBEDDED;
9617 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9618 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9619 kern_type = KERN_TYPE_OFFICE2007;
9620 dgst_size = DGST_SIZE_4_4;
9621 parse_func = office2007_parse_hash;
9622 sort_by_digest = sort_by_digest_4_4;
9623 opti_type = OPTI_TYPE_ZERO_BYTE;
9624 dgst_pos0 = 0;
9625 dgst_pos1 = 1;
9626 dgst_pos2 = 2;
9627 dgst_pos3 = 3;
9628 break;
9629
9630 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9631 salt_type = SALT_TYPE_EMBEDDED;
9632 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9633 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9634 kern_type = KERN_TYPE_OFFICE2010;
9635 dgst_size = DGST_SIZE_4_4;
9636 parse_func = office2010_parse_hash;
9637 sort_by_digest = sort_by_digest_4_4;
9638 opti_type = OPTI_TYPE_ZERO_BYTE;
9639 dgst_pos0 = 0;
9640 dgst_pos1 = 1;
9641 dgst_pos2 = 2;
9642 dgst_pos3 = 3;
9643 break;
9644
9645 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9646 salt_type = SALT_TYPE_EMBEDDED;
9647 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9648 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9649 kern_type = KERN_TYPE_OFFICE2013;
9650 dgst_size = DGST_SIZE_4_4;
9651 parse_func = office2013_parse_hash;
9652 sort_by_digest = sort_by_digest_4_4;
9653 opti_type = OPTI_TYPE_ZERO_BYTE;
9654 dgst_pos0 = 0;
9655 dgst_pos1 = 1;
9656 dgst_pos2 = 2;
9657 dgst_pos3 = 3;
9658 break;
9659
9660 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9661 salt_type = SALT_TYPE_EMBEDDED;
9662 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9663 opts_type = OPTS_TYPE_PT_GENERATE_LE
9664 | OPTS_TYPE_PT_ADD80
9665 | OPTS_TYPE_PT_UNICODE;
9666 kern_type = KERN_TYPE_OLDOFFICE01;
9667 dgst_size = DGST_SIZE_4_4;
9668 parse_func = oldoffice01_parse_hash;
9669 sort_by_digest = sort_by_digest_4_4;
9670 opti_type = OPTI_TYPE_ZERO_BYTE
9671 | OPTI_TYPE_PRECOMPUTE_INIT
9672 | OPTI_TYPE_NOT_ITERATED;
9673 dgst_pos0 = 0;
9674 dgst_pos1 = 1;
9675 dgst_pos2 = 2;
9676 dgst_pos3 = 3;
9677 break;
9678
9679 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9680 salt_type = SALT_TYPE_EMBEDDED;
9681 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9682 opts_type = OPTS_TYPE_PT_GENERATE_LE
9683 | OPTS_TYPE_PT_ADD80;
9684 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9685 dgst_size = DGST_SIZE_4_4;
9686 parse_func = oldoffice01cm1_parse_hash;
9687 sort_by_digest = sort_by_digest_4_4;
9688 opti_type = OPTI_TYPE_ZERO_BYTE
9689 | OPTI_TYPE_PRECOMPUTE_INIT
9690 | OPTI_TYPE_NOT_ITERATED;
9691 dgst_pos0 = 0;
9692 dgst_pos1 = 1;
9693 dgst_pos2 = 2;
9694 dgst_pos3 = 3;
9695 break;
9696
9697 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9698 salt_type = SALT_TYPE_EMBEDDED;
9699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9700 opts_type = OPTS_TYPE_PT_GENERATE_LE
9701 | OPTS_TYPE_PT_ADD80
9702 | OPTS_TYPE_PT_UNICODE
9703 | OPTS_TYPE_PT_NEVERCRACK;
9704 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9705 dgst_size = DGST_SIZE_4_4;
9706 parse_func = oldoffice01cm2_parse_hash;
9707 sort_by_digest = sort_by_digest_4_4;
9708 opti_type = OPTI_TYPE_ZERO_BYTE
9709 | OPTI_TYPE_PRECOMPUTE_INIT
9710 | OPTI_TYPE_NOT_ITERATED;
9711 dgst_pos0 = 0;
9712 dgst_pos1 = 1;
9713 dgst_pos2 = 2;
9714 dgst_pos3 = 3;
9715 break;
9716
9717 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9718 salt_type = SALT_TYPE_EMBEDDED;
9719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9720 opts_type = OPTS_TYPE_PT_GENERATE_BE
9721 | OPTS_TYPE_PT_ADD80
9722 | OPTS_TYPE_PT_UNICODE;
9723 kern_type = KERN_TYPE_OLDOFFICE34;
9724 dgst_size = DGST_SIZE_4_4;
9725 parse_func = oldoffice34_parse_hash;
9726 sort_by_digest = sort_by_digest_4_4;
9727 opti_type = OPTI_TYPE_ZERO_BYTE
9728 | OPTI_TYPE_PRECOMPUTE_INIT
9729 | OPTI_TYPE_NOT_ITERATED;
9730 dgst_pos0 = 0;
9731 dgst_pos1 = 1;
9732 dgst_pos2 = 2;
9733 dgst_pos3 = 3;
9734 break;
9735
9736 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9737 salt_type = SALT_TYPE_EMBEDDED;
9738 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9739 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9740 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9741 dgst_size = DGST_SIZE_4_4;
9742 parse_func = oldoffice34cm1_parse_hash;
9743 sort_by_digest = sort_by_digest_4_4;
9744 opti_type = OPTI_TYPE_ZERO_BYTE
9745 | OPTI_TYPE_PRECOMPUTE_INIT
9746 | OPTI_TYPE_NOT_ITERATED;
9747 dgst_pos0 = 0;
9748 dgst_pos1 = 1;
9749 dgst_pos2 = 2;
9750 dgst_pos3 = 3;
9751 break;
9752
9753 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9754 salt_type = SALT_TYPE_EMBEDDED;
9755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9756 opts_type = OPTS_TYPE_PT_GENERATE_BE
9757 | OPTS_TYPE_PT_ADD80
9758 | OPTS_TYPE_PT_UNICODE
9759 | OPTS_TYPE_PT_NEVERCRACK;
9760 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9761 dgst_size = DGST_SIZE_4_4;
9762 parse_func = oldoffice34cm2_parse_hash;
9763 sort_by_digest = sort_by_digest_4_4;
9764 opti_type = OPTI_TYPE_ZERO_BYTE
9765 | OPTI_TYPE_PRECOMPUTE_INIT
9766 | OPTI_TYPE_NOT_ITERATED;
9767 dgst_pos0 = 0;
9768 dgst_pos1 = 1;
9769 dgst_pos2 = 2;
9770 dgst_pos3 = 3;
9771 break;
9772
9773 case 9900: hash_type = HASH_TYPE_MD5;
9774 salt_type = SALT_TYPE_NONE;
9775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9776 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9777 kern_type = KERN_TYPE_RADMIN2;
9778 dgst_size = DGST_SIZE_4_4;
9779 parse_func = radmin2_parse_hash;
9780 sort_by_digest = sort_by_digest_4_4;
9781 opti_type = OPTI_TYPE_ZERO_BYTE
9782 | OPTI_TYPE_PRECOMPUTE_INIT
9783 | OPTI_TYPE_EARLY_SKIP
9784 | OPTI_TYPE_NOT_ITERATED
9785 | OPTI_TYPE_NOT_SALTED;
9786 dgst_pos0 = 0;
9787 dgst_pos1 = 3;
9788 dgst_pos2 = 2;
9789 dgst_pos3 = 1;
9790 break;
9791
9792 case 10000: hash_type = HASH_TYPE_SHA256;
9793 salt_type = SALT_TYPE_EMBEDDED;
9794 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9795 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9796 kern_type = KERN_TYPE_PBKDF2_SHA256;
9797 dgst_size = DGST_SIZE_4_32;
9798 parse_func = djangopbkdf2_parse_hash;
9799 sort_by_digest = sort_by_digest_4_32;
9800 opti_type = OPTI_TYPE_ZERO_BYTE;
9801 dgst_pos0 = 0;
9802 dgst_pos1 = 1;
9803 dgst_pos2 = 2;
9804 dgst_pos3 = 3;
9805 break;
9806
9807 case 10100: hash_type = HASH_TYPE_SIPHASH;
9808 salt_type = SALT_TYPE_EMBEDDED;
9809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9810 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9811 kern_type = KERN_TYPE_SIPHASH;
9812 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9813 parse_func = siphash_parse_hash;
9814 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9815 opti_type = OPTI_TYPE_ZERO_BYTE
9816 | OPTI_TYPE_NOT_ITERATED
9817 | OPTI_TYPE_RAW_HASH;
9818 dgst_pos0 = 0;
9819 dgst_pos1 = 1;
9820 dgst_pos2 = 2;
9821 dgst_pos3 = 3;
9822 break;
9823
9824 case 10200: hash_type = HASH_TYPE_MD5;
9825 salt_type = SALT_TYPE_EMBEDDED;
9826 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9827 opts_type = OPTS_TYPE_PT_GENERATE_LE
9828 | OPTS_TYPE_ST_ADD80
9829 | OPTS_TYPE_ST_ADDBITS14;
9830 kern_type = KERN_TYPE_HMACMD5_PW;
9831 dgst_size = DGST_SIZE_4_4;
9832 parse_func = crammd5_parse_hash;
9833 sort_by_digest = sort_by_digest_4_4;
9834 opti_type = OPTI_TYPE_ZERO_BYTE
9835 | OPTI_TYPE_NOT_ITERATED;
9836 dgst_pos0 = 0;
9837 dgst_pos1 = 3;
9838 dgst_pos2 = 2;
9839 dgst_pos3 = 1;
9840 break;
9841
9842 case 10300: hash_type = HASH_TYPE_SHA1;
9843 salt_type = SALT_TYPE_EMBEDDED;
9844 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9845 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9846 kern_type = KERN_TYPE_SAPH_SHA1;
9847 dgst_size = DGST_SIZE_4_5;
9848 parse_func = saph_sha1_parse_hash;
9849 sort_by_digest = sort_by_digest_4_5;
9850 opti_type = OPTI_TYPE_ZERO_BYTE;
9851 dgst_pos0 = 0;
9852 dgst_pos1 = 1;
9853 dgst_pos2 = 2;
9854 dgst_pos3 = 3;
9855 break;
9856
9857 case 10400: hash_type = HASH_TYPE_PDFU16;
9858 salt_type = SALT_TYPE_EMBEDDED;
9859 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9860 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9861 kern_type = KERN_TYPE_PDF11;
9862 dgst_size = DGST_SIZE_4_4;
9863 parse_func = pdf11_parse_hash;
9864 sort_by_digest = sort_by_digest_4_4;
9865 opti_type = OPTI_TYPE_ZERO_BYTE
9866 | OPTI_TYPE_NOT_ITERATED;
9867 dgst_pos0 = 0;
9868 dgst_pos1 = 1;
9869 dgst_pos2 = 2;
9870 dgst_pos3 = 3;
9871 break;
9872
9873 case 10410: hash_type = HASH_TYPE_PDFU16;
9874 salt_type = SALT_TYPE_EMBEDDED;
9875 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9876 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9877 kern_type = KERN_TYPE_PDF11CM1;
9878 dgst_size = DGST_SIZE_4_4;
9879 parse_func = pdf11cm1_parse_hash;
9880 sort_by_digest = sort_by_digest_4_4;
9881 opti_type = OPTI_TYPE_ZERO_BYTE
9882 | OPTI_TYPE_NOT_ITERATED;
9883 dgst_pos0 = 0;
9884 dgst_pos1 = 1;
9885 dgst_pos2 = 2;
9886 dgst_pos3 = 3;
9887 break;
9888
9889 case 10420: hash_type = HASH_TYPE_PDFU16;
9890 salt_type = SALT_TYPE_EMBEDDED;
9891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9892 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9893 kern_type = KERN_TYPE_PDF11CM2;
9894 dgst_size = DGST_SIZE_4_4;
9895 parse_func = pdf11cm2_parse_hash;
9896 sort_by_digest = sort_by_digest_4_4;
9897 opti_type = OPTI_TYPE_ZERO_BYTE
9898 | OPTI_TYPE_NOT_ITERATED;
9899 dgst_pos0 = 0;
9900 dgst_pos1 = 1;
9901 dgst_pos2 = 2;
9902 dgst_pos3 = 3;
9903 break;
9904
9905 case 10500: hash_type = HASH_TYPE_PDFU16;
9906 salt_type = SALT_TYPE_EMBEDDED;
9907 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9908 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9909 kern_type = KERN_TYPE_PDF14;
9910 dgst_size = DGST_SIZE_4_4;
9911 parse_func = pdf14_parse_hash;
9912 sort_by_digest = sort_by_digest_4_4;
9913 opti_type = OPTI_TYPE_ZERO_BYTE
9914 | OPTI_TYPE_NOT_ITERATED;
9915 dgst_pos0 = 0;
9916 dgst_pos1 = 1;
9917 dgst_pos2 = 2;
9918 dgst_pos3 = 3;
9919 break;
9920
9921 case 10600: hash_type = HASH_TYPE_SHA256;
9922 salt_type = SALT_TYPE_EMBEDDED;
9923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9924 opts_type = OPTS_TYPE_PT_GENERATE_BE
9925 | OPTS_TYPE_ST_ADD80
9926 | OPTS_TYPE_ST_ADDBITS15
9927 | OPTS_TYPE_HASH_COPY;
9928 kern_type = KERN_TYPE_SHA256_PWSLT;
9929 dgst_size = DGST_SIZE_4_8;
9930 parse_func = pdf17l3_parse_hash;
9931 sort_by_digest = sort_by_digest_4_8;
9932 opti_type = OPTI_TYPE_ZERO_BYTE
9933 | OPTI_TYPE_PRECOMPUTE_INIT
9934 | OPTI_TYPE_PRECOMPUTE_MERKLE
9935 | OPTI_TYPE_EARLY_SKIP
9936 | OPTI_TYPE_NOT_ITERATED
9937 | OPTI_TYPE_APPENDED_SALT
9938 | OPTI_TYPE_RAW_HASH;
9939 dgst_pos0 = 3;
9940 dgst_pos1 = 7;
9941 dgst_pos2 = 2;
9942 dgst_pos3 = 6;
9943 break;
9944
9945 case 10700: hash_type = HASH_TYPE_PDFU32;
9946 salt_type = SALT_TYPE_EMBEDDED;
9947 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9948 opts_type = OPTS_TYPE_PT_GENERATE_LE
9949 | OPTS_TYPE_HASH_COPY;
9950 kern_type = KERN_TYPE_PDF17L8;
9951 dgst_size = DGST_SIZE_4_8;
9952 parse_func = pdf17l8_parse_hash;
9953 sort_by_digest = sort_by_digest_4_8;
9954 opti_type = OPTI_TYPE_ZERO_BYTE
9955 | OPTI_TYPE_NOT_ITERATED;
9956 dgst_pos0 = 0;
9957 dgst_pos1 = 1;
9958 dgst_pos2 = 2;
9959 dgst_pos3 = 3;
9960 break;
9961
9962 case 10800: hash_type = HASH_TYPE_SHA384;
9963 salt_type = SALT_TYPE_NONE;
9964 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9965 opts_type = OPTS_TYPE_PT_GENERATE_BE
9966 | OPTS_TYPE_PT_ADD80
9967 | OPTS_TYPE_PT_ADDBITS15;
9968 kern_type = KERN_TYPE_SHA384;
9969 dgst_size = DGST_SIZE_8_8;
9970 parse_func = sha384_parse_hash;
9971 sort_by_digest = sort_by_digest_8_8;
9972 opti_type = OPTI_TYPE_ZERO_BYTE
9973 | OPTI_TYPE_PRECOMPUTE_INIT
9974 | OPTI_TYPE_PRECOMPUTE_MERKLE
9975 | OPTI_TYPE_EARLY_SKIP
9976 | OPTI_TYPE_NOT_ITERATED
9977 | OPTI_TYPE_NOT_SALTED
9978 | OPTI_TYPE_USES_BITS_64
9979 | OPTI_TYPE_RAW_HASH;
9980 dgst_pos0 = 6;
9981 dgst_pos1 = 7;
9982 dgst_pos2 = 4;
9983 dgst_pos3 = 5;
9984 break;
9985
9986 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9987 salt_type = SALT_TYPE_EMBEDDED;
9988 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9989 opts_type = OPTS_TYPE_PT_GENERATE_LE
9990 | OPTS_TYPE_ST_BASE64
9991 | OPTS_TYPE_HASH_COPY;
9992 kern_type = KERN_TYPE_PBKDF2_SHA256;
9993 dgst_size = DGST_SIZE_4_32;
9994 parse_func = pbkdf2_sha256_parse_hash;
9995 sort_by_digest = sort_by_digest_4_32;
9996 opti_type = OPTI_TYPE_ZERO_BYTE;
9997 dgst_pos0 = 0;
9998 dgst_pos1 = 1;
9999 dgst_pos2 = 2;
10000 dgst_pos3 = 3;
10001 break;
10002
10003 case 11000: hash_type = HASH_TYPE_MD5;
10004 salt_type = SALT_TYPE_INTERN;
10005 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10006 opts_type = OPTS_TYPE_PT_GENERATE_LE
10007 | OPTS_TYPE_PT_ADD80;
10008 kern_type = KERN_TYPE_PRESTASHOP;
10009 dgst_size = DGST_SIZE_4_4;
10010 parse_func = prestashop_parse_hash;
10011 sort_by_digest = sort_by_digest_4_4;
10012 opti_type = OPTI_TYPE_ZERO_BYTE
10013 | OPTI_TYPE_PRECOMPUTE_INIT
10014 | OPTI_TYPE_NOT_ITERATED
10015 | OPTI_TYPE_PREPENDED_SALT;
10016 dgst_pos0 = 0;
10017 dgst_pos1 = 3;
10018 dgst_pos2 = 2;
10019 dgst_pos3 = 1;
10020 break;
10021
10022 case 11100: hash_type = HASH_TYPE_MD5;
10023 salt_type = SALT_TYPE_EMBEDDED;
10024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10025 opts_type = OPTS_TYPE_PT_GENERATE_LE
10026 | OPTS_TYPE_ST_ADD80;
10027 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10028 dgst_size = DGST_SIZE_4_4;
10029 parse_func = postgresql_auth_parse_hash;
10030 sort_by_digest = sort_by_digest_4_4;
10031 opti_type = OPTI_TYPE_ZERO_BYTE
10032 | OPTI_TYPE_PRECOMPUTE_INIT
10033 | OPTI_TYPE_PRECOMPUTE_MERKLE
10034 | OPTI_TYPE_EARLY_SKIP;
10035 dgst_pos0 = 0;
10036 dgst_pos1 = 3;
10037 dgst_pos2 = 2;
10038 dgst_pos3 = 1;
10039 break;
10040
10041 case 11200: hash_type = HASH_TYPE_SHA1;
10042 salt_type = SALT_TYPE_EMBEDDED;
10043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10044 opts_type = OPTS_TYPE_PT_GENERATE_BE
10045 | OPTS_TYPE_PT_ADD80
10046 | OPTS_TYPE_ST_HEX;
10047 kern_type = KERN_TYPE_MYSQL_AUTH;
10048 dgst_size = DGST_SIZE_4_5;
10049 parse_func = mysql_auth_parse_hash;
10050 sort_by_digest = sort_by_digest_4_5;
10051 opti_type = OPTI_TYPE_ZERO_BYTE
10052 | OPTI_TYPE_EARLY_SKIP;
10053 dgst_pos0 = 3;
10054 dgst_pos1 = 4;
10055 dgst_pos2 = 2;
10056 dgst_pos3 = 1;
10057 break;
10058
10059 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10060 salt_type = SALT_TYPE_EMBEDDED;
10061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10062 opts_type = OPTS_TYPE_PT_GENERATE_LE
10063 | OPTS_TYPE_ST_HEX
10064 | OPTS_TYPE_ST_ADD80;
10065 kern_type = KERN_TYPE_BITCOIN_WALLET;
10066 dgst_size = DGST_SIZE_4_4;
10067 parse_func = bitcoin_wallet_parse_hash;
10068 sort_by_digest = sort_by_digest_4_4;
10069 opti_type = OPTI_TYPE_ZERO_BYTE;
10070 dgst_pos0 = 0;
10071 dgst_pos1 = 1;
10072 dgst_pos2 = 2;
10073 dgst_pos3 = 3;
10074 break;
10075
10076 case 11400: hash_type = HASH_TYPE_MD5;
10077 salt_type = SALT_TYPE_EMBEDDED;
10078 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10079 opts_type = OPTS_TYPE_PT_GENERATE_LE
10080 | OPTS_TYPE_PT_ADD80
10081 | OPTS_TYPE_HASH_COPY;
10082 kern_type = KERN_TYPE_SIP_AUTH;
10083 dgst_size = DGST_SIZE_4_4;
10084 parse_func = sip_auth_parse_hash;
10085 sort_by_digest = sort_by_digest_4_4;
10086 opti_type = OPTI_TYPE_ZERO_BYTE;
10087 dgst_pos0 = 0;
10088 dgst_pos1 = 3;
10089 dgst_pos2 = 2;
10090 dgst_pos3 = 1;
10091 break;
10092
10093 case 11500: hash_type = HASH_TYPE_CRC32;
10094 salt_type = SALT_TYPE_INTERN;
10095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10096 opts_type = OPTS_TYPE_PT_GENERATE_LE
10097 | OPTS_TYPE_ST_GENERATE_LE
10098 | OPTS_TYPE_ST_HEX;
10099 kern_type = KERN_TYPE_CRC32;
10100 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10101 parse_func = crc32_parse_hash;
10102 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10103 opti_type = OPTI_TYPE_ZERO_BYTE;
10104 dgst_pos0 = 0;
10105 dgst_pos1 = 1;
10106 dgst_pos2 = 2;
10107 dgst_pos3 = 3;
10108 break;
10109
10110 case 11600: hash_type = HASH_TYPE_AES;
10111 salt_type = SALT_TYPE_EMBEDDED;
10112 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10113 opts_type = OPTS_TYPE_PT_GENERATE_LE
10114 | OPTS_TYPE_PT_NEVERCRACK;
10115 kern_type = KERN_TYPE_SEVEN_ZIP;
10116 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10117 parse_func = seven_zip_parse_hash;
10118 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10119 opti_type = OPTI_TYPE_ZERO_BYTE;
10120 dgst_pos0 = 0;
10121 dgst_pos1 = 1;
10122 dgst_pos2 = 2;
10123 dgst_pos3 = 3;
10124 break;
10125
10126 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10127 salt_type = SALT_TYPE_NONE;
10128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10129 opts_type = OPTS_TYPE_PT_GENERATE_LE
10130 | OPTS_TYPE_PT_ADD01;
10131 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10132 dgst_size = DGST_SIZE_4_8;
10133 parse_func = gost2012sbog_256_parse_hash;
10134 sort_by_digest = sort_by_digest_4_8;
10135 opti_type = OPTI_TYPE_ZERO_BYTE;
10136 dgst_pos0 = 0;
10137 dgst_pos1 = 1;
10138 dgst_pos2 = 2;
10139 dgst_pos3 = 3;
10140 break;
10141
10142 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10143 salt_type = SALT_TYPE_NONE;
10144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10145 opts_type = OPTS_TYPE_PT_GENERATE_LE
10146 | OPTS_TYPE_PT_ADD01;
10147 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10148 dgst_size = DGST_SIZE_4_16;
10149 parse_func = gost2012sbog_512_parse_hash;
10150 sort_by_digest = sort_by_digest_4_16;
10151 opti_type = OPTI_TYPE_ZERO_BYTE;
10152 dgst_pos0 = 0;
10153 dgst_pos1 = 1;
10154 dgst_pos2 = 2;
10155 dgst_pos3 = 3;
10156 break;
10157
10158 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10159 salt_type = SALT_TYPE_EMBEDDED;
10160 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10161 opts_type = OPTS_TYPE_PT_GENERATE_LE
10162 | OPTS_TYPE_ST_BASE64
10163 | OPTS_TYPE_HASH_COPY;
10164 kern_type = KERN_TYPE_PBKDF2_MD5;
10165 dgst_size = DGST_SIZE_4_32;
10166 parse_func = pbkdf2_md5_parse_hash;
10167 sort_by_digest = sort_by_digest_4_32;
10168 opti_type = OPTI_TYPE_ZERO_BYTE;
10169 dgst_pos0 = 0;
10170 dgst_pos1 = 1;
10171 dgst_pos2 = 2;
10172 dgst_pos3 = 3;
10173 break;
10174
10175 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10176 salt_type = SALT_TYPE_EMBEDDED;
10177 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10178 opts_type = OPTS_TYPE_PT_GENERATE_LE
10179 | OPTS_TYPE_ST_BASE64
10180 | OPTS_TYPE_HASH_COPY;
10181 kern_type = KERN_TYPE_PBKDF2_SHA1;
10182 dgst_size = DGST_SIZE_4_32;
10183 parse_func = pbkdf2_sha1_parse_hash;
10184 sort_by_digest = sort_by_digest_4_32;
10185 opti_type = OPTI_TYPE_ZERO_BYTE;
10186 dgst_pos0 = 0;
10187 dgst_pos1 = 1;
10188 dgst_pos2 = 2;
10189 dgst_pos3 = 3;
10190 break;
10191
10192 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10193 salt_type = SALT_TYPE_EMBEDDED;
10194 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10195 opts_type = OPTS_TYPE_PT_GENERATE_LE
10196 | OPTS_TYPE_ST_BASE64
10197 | OPTS_TYPE_HASH_COPY;
10198 kern_type = KERN_TYPE_PBKDF2_SHA512;
10199 dgst_size = DGST_SIZE_8_16;
10200 parse_func = pbkdf2_sha512_parse_hash;
10201 sort_by_digest = sort_by_digest_8_16;
10202 opti_type = OPTI_TYPE_ZERO_BYTE
10203 | OPTI_TYPE_USES_BITS_64;
10204 dgst_pos0 = 0;
10205 dgst_pos1 = 1;
10206 dgst_pos2 = 2;
10207 dgst_pos3 = 3;
10208 break;
10209
10210 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10211 salt_type = SALT_TYPE_EMBEDDED;
10212 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10213 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10214 kern_type = KERN_TYPE_ECRYPTFS;
10215 dgst_size = DGST_SIZE_8_8;
10216 parse_func = ecryptfs_parse_hash;
10217 sort_by_digest = sort_by_digest_8_8;
10218 opti_type = OPTI_TYPE_ZERO_BYTE
10219 | OPTI_TYPE_USES_BITS_64;
10220 dgst_pos0 = 0;
10221 dgst_pos1 = 1;
10222 dgst_pos2 = 2;
10223 dgst_pos3 = 3;
10224 break;
10225
10226 case 12300: hash_type = HASH_TYPE_ORACLET;
10227 salt_type = SALT_TYPE_EMBEDDED;
10228 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10229 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10230 kern_type = KERN_TYPE_ORACLET;
10231 dgst_size = DGST_SIZE_8_16;
10232 parse_func = oraclet_parse_hash;
10233 sort_by_digest = sort_by_digest_8_16;
10234 opti_type = OPTI_TYPE_ZERO_BYTE
10235 | OPTI_TYPE_USES_BITS_64;
10236 dgst_pos0 = 0;
10237 dgst_pos1 = 1;
10238 dgst_pos2 = 2;
10239 dgst_pos3 = 3;
10240 break;
10241
10242 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10243 salt_type = SALT_TYPE_EMBEDDED;
10244 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10245 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10246 kern_type = KERN_TYPE_BSDICRYPT;
10247 dgst_size = DGST_SIZE_4_4;
10248 parse_func = bsdicrypt_parse_hash;
10249 sort_by_digest = sort_by_digest_4_4;
10250 opti_type = OPTI_TYPE_ZERO_BYTE
10251 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10252 dgst_pos0 = 0;
10253 dgst_pos1 = 1;
10254 dgst_pos2 = 2;
10255 dgst_pos3 = 3;
10256 break;
10257
10258 case 12500: hash_type = HASH_TYPE_RAR3HP;
10259 salt_type = SALT_TYPE_EMBEDDED;
10260 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10261 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10262 kern_type = KERN_TYPE_RAR3;
10263 dgst_size = DGST_SIZE_4_4;
10264 parse_func = rar3hp_parse_hash;
10265 sort_by_digest = sort_by_digest_4_4;
10266 opti_type = OPTI_TYPE_ZERO_BYTE;
10267 dgst_pos0 = 0;
10268 dgst_pos1 = 1;
10269 dgst_pos2 = 2;
10270 dgst_pos3 = 3;
10271 break;
10272
10273 case 12600: hash_type = HASH_TYPE_SHA256;
10274 salt_type = SALT_TYPE_INTERN;
10275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10276 opts_type = OPTS_TYPE_PT_GENERATE_BE
10277 | OPTS_TYPE_PT_ADD80;
10278 kern_type = KERN_TYPE_CF10;
10279 dgst_size = DGST_SIZE_4_8;
10280 parse_func = cf10_parse_hash;
10281 sort_by_digest = sort_by_digest_4_8;
10282 opti_type = OPTI_TYPE_ZERO_BYTE
10283 | OPTI_TYPE_PRECOMPUTE_INIT
10284 | OPTI_TYPE_EARLY_SKIP
10285 | OPTI_TYPE_NOT_ITERATED;
10286 dgst_pos0 = 3;
10287 dgst_pos1 = 7;
10288 dgst_pos2 = 2;
10289 dgst_pos3 = 6;
10290 break;
10291
10292 case 12700: hash_type = HASH_TYPE_AES;
10293 salt_type = SALT_TYPE_EMBEDDED;
10294 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10295 opts_type = OPTS_TYPE_PT_GENERATE_LE
10296 | OPTS_TYPE_HASH_COPY;
10297 kern_type = KERN_TYPE_MYWALLET;
10298 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10299 parse_func = mywallet_parse_hash;
10300 sort_by_digest = sort_by_digest_4_5;
10301 opti_type = OPTI_TYPE_ZERO_BYTE;
10302 dgst_pos0 = 0;
10303 dgst_pos1 = 1;
10304 dgst_pos2 = 2;
10305 dgst_pos3 = 3;
10306 break;
10307
10308 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10309 salt_type = SALT_TYPE_EMBEDDED;
10310 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10311 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10312 kern_type = KERN_TYPE_MS_DRSR;
10313 dgst_size = DGST_SIZE_4_8;
10314 parse_func = ms_drsr_parse_hash;
10315 sort_by_digest = sort_by_digest_4_8;
10316 opti_type = OPTI_TYPE_ZERO_BYTE;
10317 dgst_pos0 = 0;
10318 dgst_pos1 = 1;
10319 dgst_pos2 = 2;
10320 dgst_pos3 = 3;
10321 break;
10322
10323 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10324 salt_type = SALT_TYPE_EMBEDDED;
10325 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10326 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10327 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10328 dgst_size = DGST_SIZE_4_8;
10329 parse_func = androidfde_samsung_parse_hash;
10330 sort_by_digest = sort_by_digest_4_8;
10331 opti_type = OPTI_TYPE_ZERO_BYTE;
10332 dgst_pos0 = 0;
10333 dgst_pos1 = 1;
10334 dgst_pos2 = 2;
10335 dgst_pos3 = 3;
10336 break;
10337
10338 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10339 salt_type = SALT_TYPE_EMBEDDED;
10340 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10341 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10342 kern_type = KERN_TYPE_RAR5;
10343 dgst_size = DGST_SIZE_4_4;
10344 parse_func = rar5_parse_hash;
10345 sort_by_digest = sort_by_digest_4_4;
10346 opti_type = OPTI_TYPE_ZERO_BYTE;
10347 dgst_pos0 = 0;
10348 dgst_pos1 = 1;
10349 dgst_pos2 = 2;
10350 dgst_pos3 = 3;
10351 break;
10352
10353 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10354 salt_type = SALT_TYPE_EMBEDDED;
10355 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10356 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10357 kern_type = KERN_TYPE_KRB5TGS;
10358 dgst_size = DGST_SIZE_4_4;
10359 parse_func = krb5tgs_parse_hash;
10360 sort_by_digest = sort_by_digest_4_4;
10361 opti_type = OPTI_TYPE_ZERO_BYTE
10362 | OPTI_TYPE_NOT_ITERATED;
10363 dgst_pos0 = 0;
10364 dgst_pos1 = 1;
10365 dgst_pos2 = 2;
10366 dgst_pos3 = 3;
10367 break;
10368
10369 default: usage_mini_print (PROGNAME); return (-1);
10370 }
10371
10372 /**
10373 * transpose
10374 */
10375
10376 data.parse_func = parse_func;
10377
10378 /**
10379 * misc stuff
10380 */
10381
10382 if (hex_salt)
10383 {
10384 if (salt_type == SALT_TYPE_INTERN)
10385 {
10386 opts_type |= OPTS_TYPE_ST_HEX;
10387 }
10388 else
10389 {
10390 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10391
10392 return (-1);
10393 }
10394 }
10395
10396 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10397 | (salt_type == SALT_TYPE_EXTERN)
10398 | (salt_type == SALT_TYPE_EMBEDDED)
10399 | (salt_type == SALT_TYPE_VIRTUAL));
10400
10401 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10402
10403 data.hash_type = hash_type;
10404 data.attack_mode = attack_mode;
10405 data.attack_kern = attack_kern;
10406 data.attack_exec = attack_exec;
10407 data.kern_type = kern_type;
10408 data.opts_type = opts_type;
10409 data.dgst_size = dgst_size;
10410 data.salt_type = salt_type;
10411 data.isSalted = isSalted;
10412 data.sort_by_digest = sort_by_digest;
10413 data.dgst_pos0 = dgst_pos0;
10414 data.dgst_pos1 = dgst_pos1;
10415 data.dgst_pos2 = dgst_pos2;
10416 data.dgst_pos3 = dgst_pos3;
10417
10418 esalt_size = 0;
10419
10420 switch (hash_mode)
10421 {
10422 case 2500: esalt_size = sizeof (wpa_t); break;
10423 case 5300: esalt_size = sizeof (ikepsk_t); break;
10424 case 5400: esalt_size = sizeof (ikepsk_t); break;
10425 case 5500: esalt_size = sizeof (netntlm_t); break;
10426 case 5600: esalt_size = sizeof (netntlm_t); break;
10427 case 6211: esalt_size = sizeof (tc_t); break;
10428 case 6212: esalt_size = sizeof (tc_t); break;
10429 case 6213: esalt_size = sizeof (tc_t); break;
10430 case 6221: esalt_size = sizeof (tc_t); break;
10431 case 6222: esalt_size = sizeof (tc_t); break;
10432 case 6223: esalt_size = sizeof (tc_t); break;
10433 case 6231: esalt_size = sizeof (tc_t); break;
10434 case 6232: esalt_size = sizeof (tc_t); break;
10435 case 6233: esalt_size = sizeof (tc_t); break;
10436 case 6241: esalt_size = sizeof (tc_t); break;
10437 case 6242: esalt_size = sizeof (tc_t); break;
10438 case 6243: esalt_size = sizeof (tc_t); break;
10439 case 6600: esalt_size = sizeof (agilekey_t); break;
10440 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10441 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10442 case 7300: esalt_size = sizeof (rakp_t); break;
10443 case 7500: esalt_size = sizeof (krb5pa_t); break;
10444 case 8200: esalt_size = sizeof (cloudkey_t); break;
10445 case 8800: esalt_size = sizeof (androidfde_t); break;
10446 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10447 case 9400: esalt_size = sizeof (office2007_t); break;
10448 case 9500: esalt_size = sizeof (office2010_t); break;
10449 case 9600: esalt_size = sizeof (office2013_t); break;
10450 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10451 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10452 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10453 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10454 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10455 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10456 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10457 case 10200: esalt_size = sizeof (cram_md5_t); break;
10458 case 10400: esalt_size = sizeof (pdf_t); break;
10459 case 10410: esalt_size = sizeof (pdf_t); break;
10460 case 10420: esalt_size = sizeof (pdf_t); break;
10461 case 10500: esalt_size = sizeof (pdf_t); break;
10462 case 10600: esalt_size = sizeof (pdf_t); break;
10463 case 10700: esalt_size = sizeof (pdf_t); break;
10464 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10465 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10466 case 11400: esalt_size = sizeof (sip_t); break;
10467 case 11600: esalt_size = sizeof (seven_zip_t); break;
10468 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10469 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10470 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10471 case 13000: esalt_size = sizeof (rar5_t); break;
10472 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10473 }
10474
10475 data.esalt_size = esalt_size;
10476
10477 /**
10478 * choose dictionary parser
10479 */
10480
10481 if (hash_type == HASH_TYPE_LM)
10482 {
10483 get_next_word_func = get_next_word_lm;
10484 }
10485 else if (opts_type & OPTS_TYPE_PT_UPPER)
10486 {
10487 get_next_word_func = get_next_word_uc;
10488 }
10489 else
10490 {
10491 get_next_word_func = get_next_word_std;
10492 }
10493
10494 /**
10495 * dictstat
10496 */
10497
10498 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10499
10500 #ifdef _POSIX
10501 size_t dictstat_nmemb = 0;
10502 #endif
10503
10504 #ifdef _WIN
10505 uint dictstat_nmemb = 0;
10506 #endif
10507
10508 char dictstat[256] = { 0 };
10509
10510 FILE *dictstat_fp = NULL;
10511
10512 if (keyspace == 0)
10513 {
10514 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10515
10516 dictstat_fp = fopen (dictstat, "rb");
10517
10518 if (dictstat_fp)
10519 {
10520 #ifdef _POSIX
10521 struct stat tmpstat;
10522
10523 fstat (fileno (dictstat_fp), &tmpstat);
10524 #endif
10525
10526 #ifdef _WIN
10527 struct stat64 tmpstat;
10528
10529 _fstat64 (fileno (dictstat_fp), &tmpstat);
10530 #endif
10531
10532 if (tmpstat.st_mtime < COMPTIME)
10533 {
10534 /* with v0.15 the format changed so we have to ensure user is using a good version
10535 since there is no version-header in the dictstat file */
10536
10537 fclose (dictstat_fp);
10538
10539 unlink (dictstat);
10540 }
10541 else
10542 {
10543 while (!feof (dictstat_fp))
10544 {
10545 dictstat_t d;
10546
10547 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10548
10549 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10550
10551 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10552 {
10553 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10554
10555 return -1;
10556 }
10557 }
10558
10559 fclose (dictstat_fp);
10560 }
10561 }
10562 }
10563
10564 /**
10565 * potfile
10566 */
10567
10568 char potfile[256] = { 0 };
10569
10570 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10571
10572 data.pot_fp = NULL;
10573
10574 FILE *out_fp = NULL;
10575 FILE *pot_fp = NULL;
10576
10577 if (show == 1 || left == 1)
10578 {
10579 pot_fp = fopen (potfile, "rb");
10580
10581 if (pot_fp == NULL)
10582 {
10583 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10584
10585 return (-1);
10586 }
10587
10588 if (outfile != NULL)
10589 {
10590 if ((out_fp = fopen (outfile, "ab")) == NULL)
10591 {
10592 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10593
10594 fclose (pot_fp);
10595
10596 return (-1);
10597 }
10598 }
10599 else
10600 {
10601 out_fp = stdout;
10602 }
10603 }
10604 else
10605 {
10606 if (potfile_disable == 0)
10607 {
10608 pot_fp = fopen (potfile, "ab");
10609
10610 if (pot_fp == NULL)
10611 {
10612 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10613
10614 return (-1);
10615 }
10616
10617 data.pot_fp = pot_fp;
10618 }
10619 }
10620
10621 pot_t *pot = NULL;
10622
10623 uint pot_cnt = 0;
10624 uint pot_avail = 0;
10625
10626 if (show == 1 || left == 1)
10627 {
10628 SUPPRESS_OUTPUT = 1;
10629
10630 pot_avail = count_lines (pot_fp);
10631
10632 rewind (pot_fp);
10633
10634 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10635
10636 uint pot_hashes_avail = 0;
10637
10638 uint line_num = 0;
10639
10640 while (!feof (pot_fp))
10641 {
10642 line_num++;
10643
10644 char line_buf[BUFSIZ] = { 0 };
10645
10646 int line_len = fgetl (pot_fp, line_buf);
10647
10648 if (line_len == 0) continue;
10649
10650 char *plain_buf = line_buf + line_len;
10651
10652 pot_t *pot_ptr = &pot[pot_cnt];
10653
10654 hash_t *hashes_buf = &pot_ptr->hash;
10655
10656 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10657 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10658
10659 if (pot_cnt == pot_hashes_avail)
10660 {
10661 uint pos = 0;
10662
10663 for (pos = 0; pos < INCR_POT; pos++)
10664 {
10665 if ((pot_cnt + pos) >= pot_avail) break;
10666
10667 pot_t *tmp_pot = &pot[pot_cnt + pos];
10668
10669 hash_t *tmp_hash = &tmp_pot->hash;
10670
10671 tmp_hash->digest = mymalloc (dgst_size);
10672
10673 if (isSalted)
10674 {
10675 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10676 }
10677
10678 if (esalt_size)
10679 {
10680 tmp_hash->esalt = mymalloc (esalt_size);
10681 }
10682
10683 pot_hashes_avail++;
10684 }
10685 }
10686
10687 int plain_len = 0;
10688
10689 int parser_status;
10690
10691 int iter = MAX_CUT_TRIES;
10692
10693 do
10694 {
10695 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10696 {
10697 if (line_buf[i] == ':')
10698 {
10699 line_len--;
10700
10701 break;
10702 }
10703 }
10704
10705 if (data.hash_mode != 2500)
10706 {
10707 parser_status = parse_func (line_buf, line_len, hashes_buf);
10708 }
10709 else
10710 {
10711 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10712
10713 if (line_len > max_salt_size)
10714 {
10715 parser_status = PARSER_GLOBAL_LENGTH;
10716 }
10717 else
10718 {
10719 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10720
10721 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10722
10723 hashes_buf->salt->salt_len = line_len;
10724
10725 parser_status = PARSER_OK;
10726 }
10727 }
10728
10729 // if NOT parsed without error, we add the ":" to the plain
10730
10731 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10732 {
10733 plain_len++;
10734 plain_buf--;
10735 }
10736
10737 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10738
10739 if (parser_status < PARSER_GLOBAL_ZERO)
10740 {
10741 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10742
10743 continue;
10744 }
10745
10746 if (plain_len >= 255) continue;
10747
10748 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10749
10750 pot_ptr->plain_len = plain_len;
10751
10752 pot_cnt++;
10753 }
10754
10755 fclose (pot_fp);
10756
10757 SUPPRESS_OUTPUT = 0;
10758
10759 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10760 }
10761
10762 /**
10763 * word len
10764 */
10765
10766 uint pw_min = PW_MIN;
10767 uint pw_max = PW_MAX;
10768
10769 switch (hash_mode)
10770 {
10771 case 400: if (pw_max > 40) pw_max = 40;
10772 break;
10773 case 500: if (pw_max > 16) pw_max = 16;
10774 break;
10775 case 1500: if (pw_max > 8) pw_max = 8;
10776 break;
10777 case 1600: if (pw_max > 16) pw_max = 16;
10778 break;
10779 case 1800: if (pw_max > 16) pw_max = 16;
10780 break;
10781 case 2100: if (pw_max > 16) pw_max = 16;
10782 break;
10783 case 2500: if (pw_min < 8) pw_min = 8;
10784 break;
10785 case 3000: if (pw_max > 7) pw_max = 7;
10786 break;
10787 case 5200: if (pw_max > 24) pw_max = 24;
10788 break;
10789 case 5800: if (pw_max > 16) pw_max = 16;
10790 break;
10791 case 6300: if (pw_max > 16) pw_max = 16;
10792 break;
10793 case 7400: if (pw_max > 16) pw_max = 16;
10794 break;
10795 case 7900: if (pw_max > 48) pw_max = 48;
10796 break;
10797 case 8500: if (pw_max > 8) pw_max = 8;
10798 break;
10799 case 8600: if (pw_max > 16) pw_max = 16;
10800 break;
10801 case 9710: pw_min = 5;
10802 pw_max = 5;
10803 break;
10804 case 9810: pw_min = 5;
10805 pw_max = 5;
10806 break;
10807 case 10410: pw_min = 5;
10808 pw_max = 5;
10809 break;
10810 case 10300: if (pw_max < 3) pw_min = 3;
10811 if (pw_max > 40) pw_max = 40;
10812 break;
10813 case 10500: if (pw_max < 3) pw_min = 3;
10814 if (pw_max > 40) pw_max = 40;
10815 break;
10816 case 10700: if (pw_max > 16) pw_max = 16;
10817 break;
10818 case 11300: if (pw_max > 40) pw_max = 40;
10819 break;
10820 case 12500: if (pw_max > 20) pw_max = 20;
10821 break;
10822 case 12800: if (pw_max > 24) pw_max = 24;
10823 break;
10824 }
10825
10826 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10827 {
10828 switch (attack_kern)
10829 {
10830 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10831 break;
10832 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10833 break;
10834 }
10835 }
10836
10837 /**
10838 * charsets : keep them together for more easy maintainnce
10839 */
10840
10841 cs_t mp_sys[6] = { { { 0 }, 0 } };
10842 cs_t mp_usr[4] = { { { 0 }, 0 } };
10843
10844 mp_setup_sys (mp_sys);
10845
10846 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10847 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10848 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10849 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10850
10851 /**
10852 * load hashes, part I: find input mode, count hashes
10853 */
10854
10855 uint hashlist_mode = 0;
10856 uint hashlist_format = HLFMT_HASHCAT;
10857
10858 uint hashes_avail = 0;
10859
10860 if (benchmark == 0)
10861 {
10862 struct stat f;
10863
10864 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10865
10866 if ((hash_mode == 2500) ||
10867 (hash_mode == 5200) ||
10868 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10869 (hash_mode == 9000))
10870 {
10871 hashlist_mode = HL_MODE_ARG;
10872
10873 char *hashfile = myargv[optind];
10874
10875 data.hashfile = hashfile;
10876
10877 logfile_top_var_string ("target", hashfile);
10878 }
10879
10880 if (hashlist_mode == HL_MODE_ARG)
10881 {
10882 if (hash_mode == 2500)
10883 {
10884 struct stat st;
10885
10886 if (stat (data.hashfile, &st) == -1)
10887 {
10888 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10889
10890 return (-1);
10891 }
10892
10893 hashes_avail = st.st_size / sizeof (hccap_t);
10894 }
10895 else
10896 {
10897 hashes_avail = 1;
10898 }
10899 }
10900 else if (hashlist_mode == HL_MODE_FILE)
10901 {
10902 char *hashfile = myargv[optind];
10903
10904 data.hashfile = hashfile;
10905
10906 logfile_top_var_string ("target", hashfile);
10907
10908 FILE *fp = NULL;
10909
10910 if ((fp = fopen (hashfile, "rb")) == NULL)
10911 {
10912 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10913
10914 return (-1);
10915 }
10916
10917 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10918
10919 hashes_avail = count_lines (fp);
10920
10921 rewind (fp);
10922
10923 if (hashes_avail == 0)
10924 {
10925 log_error ("ERROR: hashfile is empty or corrupt");
10926
10927 fclose (fp);
10928
10929 return (-1);
10930 }
10931
10932 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10933
10934 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10935 {
10936 log_error ("ERROR: remove not supported in native hashfile-format mode");
10937
10938 fclose (fp);
10939
10940 return (-1);
10941 }
10942
10943 fclose (fp);
10944 }
10945 }
10946 else
10947 {
10948 hashlist_mode = HL_MODE_ARG;
10949
10950 hashes_avail = 1;
10951 }
10952
10953 if (hash_mode == 3000) hashes_avail *= 2;
10954
10955 data.hashlist_mode = hashlist_mode;
10956 data.hashlist_format = hashlist_format;
10957
10958 logfile_top_uint (hashlist_mode);
10959 logfile_top_uint (hashlist_format);
10960
10961 /**
10962 * load hashes, part II: allocate required memory, set pointers
10963 */
10964
10965 hash_t *hashes_buf = NULL;
10966 void *digests_buf = NULL;
10967 salt_t *salts_buf = NULL;
10968 void *esalts_buf = NULL;
10969
10970 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10971
10972 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10973
10974 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10975 {
10976 u32 hash_pos;
10977
10978 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10979 {
10980 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10981
10982 hashes_buf[hash_pos].hash_info = hash_info;
10983
10984 if (username && (remove || show || left))
10985 {
10986 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10987 }
10988
10989 if (benchmark)
10990 {
10991 hash_info->orighash = (char *) mymalloc (256);
10992 }
10993 }
10994 }
10995
10996 if (isSalted)
10997 {
10998 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10999
11000 if (esalt_size)
11001 {
11002 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11003 }
11004 }
11005 else
11006 {
11007 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11008 }
11009
11010 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11011 {
11012 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11013
11014 if (isSalted)
11015 {
11016 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11017
11018 if (esalt_size)
11019 {
11020 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11021 }
11022 }
11023 else
11024 {
11025 hashes_buf[hash_pos].salt = &salts_buf[0];
11026 }
11027 }
11028
11029 /**
11030 * load hashes, part III: parse hashes or generate them if benchmark
11031 */
11032
11033 uint hashes_cnt = 0;
11034
11035 if (benchmark == 0)
11036 {
11037 if (keyspace == 1)
11038 {
11039 // useless to read hash file for keyspace, cheat a little bit w/ optind
11040 }
11041 else if (hashes_avail == 0)
11042 {
11043 }
11044 else if (hashlist_mode == HL_MODE_ARG)
11045 {
11046 char *input_buf = myargv[optind];
11047
11048 uint input_len = strlen (input_buf);
11049
11050 logfile_top_var_string ("target", input_buf);
11051
11052 char *hash_buf = NULL;
11053 int hash_len = 0;
11054
11055 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11056
11057 if (hash_len)
11058 {
11059 if (opts_type & OPTS_TYPE_HASH_COPY)
11060 {
11061 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11062
11063 hash_info_tmp->orighash = mystrdup (hash_buf);
11064 }
11065
11066 if (isSalted)
11067 {
11068 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11069 }
11070
11071 int parser_status = PARSER_OK;
11072
11073 if (hash_mode == 2500)
11074 {
11075 if (hash_len == 0)
11076 {
11077 log_error ("ERROR: hccap file not specified");
11078
11079 return (-1);
11080 }
11081
11082 hashlist_mode = HL_MODE_FILE;
11083
11084 data.hashlist_mode = hashlist_mode;
11085
11086 FILE *fp = fopen (hash_buf, "rb");
11087
11088 if (fp == NULL)
11089 {
11090 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11091
11092 return (-1);
11093 }
11094
11095 if (hashes_avail < 1)
11096 {
11097 log_error ("ERROR: hccap file is empty or corrupt");
11098
11099 fclose (fp);
11100
11101 return (-1);
11102 }
11103
11104 uint hccap_size = sizeof (hccap_t);
11105
11106 char *in = (char *) mymalloc (hccap_size);
11107
11108 while (!feof (fp))
11109 {
11110 int n = fread (in, hccap_size, 1, fp);
11111
11112 if (n != 1)
11113 {
11114 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11115
11116 break;
11117 }
11118
11119 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11120
11121 if (parser_status != PARSER_OK)
11122 {
11123 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11124
11125 continue;
11126 }
11127
11128 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11129
11130 if ((show == 1) || (left == 1))
11131 {
11132 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11133
11134 char *salt_ptr = (char *) tmp_salt->salt_buf;
11135
11136 int cur_pos = tmp_salt->salt_len;
11137 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11138
11139 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11140
11141 u8 *pke_ptr = (u8 *) wpa->pke;
11142
11143 // do the appending task
11144
11145 snprintf (salt_ptr + cur_pos,
11146 rem_len,
11147 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11148 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
11149 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
11150
11151
11152 // memset () the remaining part of the salt
11153
11154 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11155 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11156
11157 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11158
11159 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11160 }
11161
11162 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);
11163 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);
11164
11165 hashes_cnt++;
11166 }
11167
11168 fclose (fp);
11169
11170 myfree (in);
11171 }
11172 else if (hash_mode == 3000)
11173 {
11174 if (hash_len == 32)
11175 {
11176 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11177
11178 hash_t *lm_hash_left = NULL;
11179
11180 if (parser_status == PARSER_OK)
11181 {
11182 lm_hash_left = &hashes_buf[hashes_cnt];
11183
11184 hashes_cnt++;
11185 }
11186 else
11187 {
11188 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11189 }
11190
11191 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11192
11193 hash_t *lm_hash_right = NULL;
11194
11195 if (parser_status == PARSER_OK)
11196 {
11197 lm_hash_right = &hashes_buf[hashes_cnt];
11198
11199 hashes_cnt++;
11200 }
11201 else
11202 {
11203 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11204 }
11205
11206 // show / left
11207
11208 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11209 {
11210 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);
11211 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);
11212 }
11213 }
11214 else
11215 {
11216 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11217
11218 if (parser_status == PARSER_OK)
11219 {
11220 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11221 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11222 }
11223
11224 if (parser_status == PARSER_OK)
11225 {
11226 hashes_cnt++;
11227 }
11228 else
11229 {
11230 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11231 }
11232 }
11233 }
11234 else
11235 {
11236 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11237
11238 if (parser_status == PARSER_OK)
11239 {
11240 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11241 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11242 }
11243
11244 if (parser_status == PARSER_OK)
11245 {
11246 hashes_cnt++;
11247 }
11248 else
11249 {
11250 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11251 }
11252 }
11253 }
11254 }
11255 else if (hashlist_mode == HL_MODE_FILE)
11256 {
11257 char *hashfile = data.hashfile;
11258
11259 FILE *fp;
11260
11261 if ((fp = fopen (hashfile, "rb")) == NULL)
11262 {
11263 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11264
11265 return (-1);
11266 }
11267
11268 uint line_num = 0;
11269
11270 while (!feof (fp))
11271 {
11272 line_num++;
11273
11274 char line_buf[BUFSIZ] = { 0 };
11275
11276 int line_len = fgetl (fp, line_buf);
11277
11278 if (line_len == 0) continue;
11279
11280 char *hash_buf = NULL;
11281 int hash_len = 0;
11282
11283 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11284
11285 if (username)
11286 {
11287 char *user_buf = NULL;
11288 int user_len = 0;
11289
11290 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11291
11292 if (remove || show)
11293 {
11294 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11295
11296 *user = (user_t *) mymalloc (sizeof (user_t));
11297
11298 user_t *user_ptr = *user;
11299
11300 if (user_buf != NULL)
11301 {
11302 user_ptr->user_name = mystrdup (user_buf);
11303 }
11304 else
11305 {
11306 user_ptr->user_name = mystrdup ("");
11307 }
11308
11309 user_ptr->user_len = user_len;
11310 }
11311 }
11312
11313 if (opts_type & OPTS_TYPE_HASH_COPY)
11314 {
11315 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11316
11317 hash_info_tmp->orighash = mystrdup (hash_buf);
11318 }
11319
11320 if (isSalted)
11321 {
11322 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11323 }
11324
11325 if (hash_mode == 3000)
11326 {
11327 if (hash_len == 32)
11328 {
11329 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11330
11331 if (parser_status < PARSER_GLOBAL_ZERO)
11332 {
11333 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11334
11335 continue;
11336 }
11337
11338 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11339
11340 hashes_cnt++;
11341
11342 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11343
11344 if (parser_status < PARSER_GLOBAL_ZERO)
11345 {
11346 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11347
11348 continue;
11349 }
11350
11351 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11352
11353 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);
11354
11355 hashes_cnt++;
11356
11357 // show / left
11358
11359 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);
11360 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);
11361 }
11362 else
11363 {
11364 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11365
11366 if (parser_status < PARSER_GLOBAL_ZERO)
11367 {
11368 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11369
11370 continue;
11371 }
11372
11373 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);
11374
11375 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11376 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11377
11378 hashes_cnt++;
11379 }
11380 }
11381 else
11382 {
11383 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11384
11385 if (parser_status < PARSER_GLOBAL_ZERO)
11386 {
11387 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11388
11389 continue;
11390 }
11391
11392 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);
11393
11394 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11395 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11396
11397 hashes_cnt++;
11398 }
11399 }
11400
11401 fclose (fp);
11402
11403 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11404
11405 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11406 }
11407 }
11408 else
11409 {
11410 if (isSalted)
11411 {
11412 hashes_buf[0].salt->salt_len = 8;
11413
11414 // special salt handling
11415
11416 switch (hash_mode)
11417 {
11418 case 1500: hashes_buf[0].salt->salt_len = 2;
11419 break;
11420 case 1731: hashes_buf[0].salt->salt_len = 4;
11421 break;
11422 case 2410: hashes_buf[0].salt->salt_len = 4;
11423 break;
11424 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11425 break;
11426 case 3100: hashes_buf[0].salt->salt_len = 1;
11427 break;
11428 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11429 break;
11430 case 5800: hashes_buf[0].salt->salt_len = 16;
11431 break;
11432 case 6800: hashes_buf[0].salt->salt_len = 32;
11433 break;
11434 case 8400: hashes_buf[0].salt->salt_len = 40;
11435 break;
11436 case 8800: hashes_buf[0].salt->salt_len = 16;
11437 break;
11438 case 8900: hashes_buf[0].salt->salt_len = 16;
11439 hashes_buf[0].salt->scrypt_N = 1024;
11440 hashes_buf[0].salt->scrypt_r = 1;
11441 hashes_buf[0].salt->scrypt_p = 1;
11442 break;
11443 case 9100: hashes_buf[0].salt->salt_len = 16;
11444 break;
11445 case 9300: hashes_buf[0].salt->salt_len = 14;
11446 hashes_buf[0].salt->scrypt_N = 16384;
11447 hashes_buf[0].salt->scrypt_r = 1;
11448 hashes_buf[0].salt->scrypt_p = 1;
11449 break;
11450 case 9400: hashes_buf[0].salt->salt_len = 16;
11451 break;
11452 case 9500: hashes_buf[0].salt->salt_len = 16;
11453 break;
11454 case 9600: hashes_buf[0].salt->salt_len = 16;
11455 break;
11456 case 9700: hashes_buf[0].salt->salt_len = 16;
11457 break;
11458 case 9710: hashes_buf[0].salt->salt_len = 16;
11459 break;
11460 case 9720: hashes_buf[0].salt->salt_len = 16;
11461 break;
11462 case 9800: hashes_buf[0].salt->salt_len = 16;
11463 break;
11464 case 9810: hashes_buf[0].salt->salt_len = 16;
11465 break;
11466 case 9820: hashes_buf[0].salt->salt_len = 16;
11467 break;
11468 case 10300: hashes_buf[0].salt->salt_len = 12;
11469 break;
11470 case 11500: hashes_buf[0].salt->salt_len = 4;
11471 break;
11472 case 11600: hashes_buf[0].salt->salt_len = 4;
11473 break;
11474 case 12400: hashes_buf[0].salt->salt_len = 4;
11475 break;
11476 case 12500: hashes_buf[0].salt->salt_len = 8;
11477 break;
11478 case 12600: hashes_buf[0].salt->salt_len = 64;
11479 break;
11480 }
11481
11482 // special esalt handling
11483
11484 switch (hash_mode)
11485 {
11486 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11487 break;
11488 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11489 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11490 break;
11491 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11492 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11493 break;
11494 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11495 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11496 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11497 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11498 break;
11499 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11500 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11501 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11502 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11503 break;
11504 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11505 break;
11506 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11507 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11508 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11509 break;
11510 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11511 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11512 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11513 break;
11514 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11515 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11516 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11517 break;
11518 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11519 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11520 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11521 break;
11522 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11523 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11524 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11525 break;
11526 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11527 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11528 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11529 break;
11530 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11531 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11532 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11533 break;
11534 }
11535 }
11536
11537 // set hashfile
11538
11539 switch (hash_mode)
11540 {
11541 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11542 break;
11543 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11544 break;
11545 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11546 break;
11547 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11548 break;
11549 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11550 break;
11551 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11552 break;
11553 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11554 break;
11555 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11556 break;
11557 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11558 break;
11559 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11560 break;
11561 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11562 break;
11563 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11564 break;
11565 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11566 break;
11567 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11568 break;
11569 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11570 break;
11571 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11572 break;
11573 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11574 break;
11575 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11576 break;
11577 }
11578
11579 // set default iterations
11580
11581 switch (hash_mode)
11582 {
11583 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11584 break;
11585 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11586 break;
11587 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11588 break;
11589 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11590 break;
11591 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11592 break;
11593 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11594 break;
11595 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11596 break;
11597 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11598 break;
11599 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11600 break;
11601 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11602 break;
11603 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11604 break;
11605 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11606 break;
11607 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11608 break;
11609 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11610 break;
11611 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11612 break;
11613 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11614 break;
11615 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11616 break;
11617 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11618 break;
11619 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11620 break;
11621 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11622 break;
11623 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11624 break;
11625 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11626 break;
11627 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11628 break;
11629 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11630 break;
11631 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11632 break;
11633 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11634 break;
11635 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11636 break;
11637 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11638 break;
11639 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11640 break;
11641 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11642 break;
11643 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11644 break;
11645 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11646 break;
11647 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11648 break;
11649 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11650 break;
11651 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11652 break;
11653 case 8900: hashes_buf[0].salt->salt_iter = 1;
11654 break;
11655 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11656 break;
11657 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11658 break;
11659 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11660 break;
11661 case 9300: hashes_buf[0].salt->salt_iter = 1;
11662 break;
11663 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11664 break;
11665 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11666 break;
11667 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11668 break;
11669 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11670 break;
11671 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11672 break;
11673 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11674 break;
11675 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11676 break;
11677 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11678 break;
11679 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11680 break;
11681 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11682 break;
11683 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11684 break;
11685 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11686 break;
11687 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11688 break;
11689 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11690 break;
11691 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11692 break;
11693 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11694 break;
11695 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11696 break;
11697 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11698 break;
11699 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11700 break;
11701 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11702 break;
11703 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11704 break;
11705 }
11706
11707 hashes_cnt = 1;
11708 }
11709
11710 if (show == 1 || left == 1)
11711 {
11712 for (uint i = 0; i < pot_cnt; i++)
11713 {
11714 pot_t *pot_ptr = &pot[i];
11715
11716 hash_t *hashes_buf = &pot_ptr->hash;
11717
11718 local_free (hashes_buf->digest);
11719
11720 if (isSalted)
11721 {
11722 local_free (hashes_buf->salt);
11723 }
11724 }
11725
11726 local_free (pot);
11727
11728 if (data.quiet == 0) log_info_nn ("");
11729
11730 return (0);
11731 }
11732
11733 if (keyspace == 0)
11734 {
11735 if (hashes_cnt == 0)
11736 {
11737 log_error ("ERROR: No hashes loaded");
11738
11739 return (-1);
11740 }
11741 }
11742
11743 /**
11744 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11745 */
11746
11747 if (data.outfile != NULL)
11748 {
11749 if (data.hashfile != NULL)
11750 {
11751 #ifdef _POSIX
11752 struct stat tmpstat_outfile;
11753 struct stat tmpstat_hashfile;
11754 #endif
11755
11756 #ifdef _WIN
11757 struct stat64 tmpstat_outfile;
11758 struct stat64 tmpstat_hashfile;
11759 #endif
11760
11761 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11762
11763 if (tmp_outfile_fp)
11764 {
11765 #ifdef _POSIX
11766 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11767 #endif
11768
11769 #ifdef _WIN
11770 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11771 #endif
11772
11773 fclose (tmp_outfile_fp);
11774 }
11775
11776 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11777
11778 if (tmp_hashfile_fp)
11779 {
11780 #ifdef _POSIX
11781 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11782 #endif
11783
11784 #ifdef _WIN
11785 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11786 #endif
11787
11788 fclose (tmp_hashfile_fp);
11789 }
11790
11791 if (tmp_outfile_fp && tmp_outfile_fp)
11792 {
11793 tmpstat_outfile.st_mode = 0;
11794 tmpstat_outfile.st_nlink = 0;
11795 tmpstat_outfile.st_uid = 0;
11796 tmpstat_outfile.st_gid = 0;
11797 tmpstat_outfile.st_rdev = 0;
11798 tmpstat_outfile.st_atime = 0;
11799
11800 tmpstat_hashfile.st_mode = 0;
11801 tmpstat_hashfile.st_nlink = 0;
11802 tmpstat_hashfile.st_uid = 0;
11803 tmpstat_hashfile.st_gid = 0;
11804 tmpstat_hashfile.st_rdev = 0;
11805 tmpstat_hashfile.st_atime = 0;
11806
11807 #ifdef _POSIX
11808 tmpstat_outfile.st_blksize = 0;
11809 tmpstat_outfile.st_blocks = 0;
11810
11811 tmpstat_hashfile.st_blksize = 0;
11812 tmpstat_hashfile.st_blocks = 0;
11813 #endif
11814
11815 #ifdef _POSIX
11816 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11817 {
11818 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11819
11820 return (-1);
11821 }
11822 #endif
11823
11824 #ifdef _WIN
11825 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11826 {
11827 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11828
11829 return (-1);
11830 }
11831 #endif
11832 }
11833 }
11834 }
11835
11836 /**
11837 * Remove duplicates
11838 */
11839
11840 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11841
11842 if (isSalted)
11843 {
11844 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11845 }
11846 else
11847 {
11848 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11849 }
11850
11851 uint hashes_cnt_orig = hashes_cnt;
11852
11853 hashes_cnt = 1;
11854
11855 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11856 {
11857 if (isSalted)
11858 {
11859 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11860 {
11861 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11862 }
11863 }
11864 else
11865 {
11866 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11867 }
11868
11869 if (hashes_pos > hashes_cnt)
11870 {
11871 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11872 }
11873
11874 hashes_cnt++;
11875 }
11876
11877 /**
11878 * Potfile removes
11879 */
11880
11881 uint potfile_remove_cracks = 0;
11882
11883 if (potfile_disable == 0)
11884 {
11885 hash_t hash_buf;
11886
11887 hash_buf.digest = mymalloc (dgst_size);
11888 hash_buf.salt = NULL;
11889 hash_buf.esalt = NULL;
11890 hash_buf.hash_info = NULL;
11891 hash_buf.cracked = 0;
11892
11893 if (isSalted)
11894 {
11895 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11896 }
11897
11898 if (esalt_size)
11899 {
11900 hash_buf.esalt = mymalloc (esalt_size);
11901 }
11902
11903 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11904
11905 // no solution for these special hash types (for instane because they use hashfile in output etc)
11906 if ((hash_mode != 5200) &&
11907 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11908 (hash_mode != 9000))
11909 {
11910 FILE *fp = fopen (potfile, "rb");
11911
11912 if (fp != NULL)
11913 {
11914 while (!feof (fp))
11915 {
11916 char line_buf[BUFSIZ] = { 0 };
11917
11918 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11919
11920 if (ptr == NULL) break;
11921
11922 int line_len = strlen (line_buf);
11923
11924 if (line_len == 0) continue;
11925
11926 int iter = MAX_CUT_TRIES;
11927
11928 for (int i = line_len - 1; i && iter; i--, line_len--)
11929 {
11930 if (line_buf[i] != ':') continue;
11931
11932 if (isSalted)
11933 {
11934 memset (hash_buf.salt, 0, sizeof (salt_t));
11935 }
11936
11937 hash_t *found = NULL;
11938
11939 if (hash_mode == 6800)
11940 {
11941 if (i < 64) // 64 = 16 * uint in salt_buf[]
11942 {
11943 // manipulate salt_buf
11944 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11945
11946 hash_buf.salt->salt_len = i;
11947
11948 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11949 }
11950 }
11951 else if (hash_mode == 2500)
11952 {
11953 if (i < 64) // 64 = 16 * uint in salt_buf[]
11954 {
11955 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11956 // manipulate salt_buf
11957
11958 // to be safe work with a copy (because of line_len loop, i etc)
11959
11960 char line_buf_cpy[BUFSIZ] = { 0 };
11961
11962 memcpy (line_buf_cpy, line_buf, i);
11963
11964 char *mac2_pos = strrchr (line_buf_cpy, ':');
11965
11966 if (mac2_pos == NULL) continue;
11967
11968 mac2_pos[0] = 0;
11969 mac2_pos++;
11970
11971 if (strlen (mac2_pos) != 12) continue;
11972
11973 char *mac1_pos = strrchr (line_buf_cpy, ':');
11974
11975 if (mac1_pos == NULL) continue;
11976
11977 mac1_pos[0] = 0;
11978 mac1_pos++;
11979
11980 if (strlen (mac1_pos) != 12) continue;
11981
11982 uint essid_length = mac1_pos - line_buf_cpy - 1;
11983
11984 // here we need the ESSID
11985 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11986
11987 hash_buf.salt->salt_len = essid_length;
11988
11989 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11990
11991 if (found)
11992 {
11993 wpa_t *wpa = (wpa_t *) found->esalt;
11994
11995 uint pke[25] = { 0 };
11996
11997 char *pke_ptr = (char *) pke;
11998
11999 for (uint i = 0; i < 25; i++)
12000 {
12001 pke[i] = byte_swap_32 (wpa->pke[i]);
12002 }
12003
12004 u8 mac1[6] = { 0 };
12005 u8 mac2[6] = { 0 };
12006
12007 memcpy (mac1, pke_ptr + 23, 6);
12008 memcpy (mac2, pke_ptr + 29, 6);
12009
12010 // compare hex string(s) vs binary MAC address(es)
12011
12012 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12013 {
12014 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12015 {
12016 found = NULL;
12017 break;
12018 }
12019 }
12020
12021 // early skip ;)
12022 if (!found) continue;
12023
12024 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12025 {
12026 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12027 {
12028 found = NULL;
12029 break;
12030 }
12031 }
12032 }
12033 }
12034 }
12035 else
12036 {
12037 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12038
12039 if (parser_status == PARSER_OK)
12040 {
12041 if (isSalted)
12042 {
12043 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12044 }
12045 else
12046 {
12047 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12048 }
12049 }
12050 }
12051
12052 if (found == NULL) continue;
12053
12054 if (!found->cracked) potfile_remove_cracks++;
12055
12056 found->cracked = 1;
12057
12058 if (found) break;
12059
12060 iter--;
12061 }
12062 }
12063
12064 fclose (fp);
12065 }
12066 }
12067
12068 if (esalt_size)
12069 {
12070 local_free (hash_buf.esalt);
12071 }
12072
12073 if (isSalted)
12074 {
12075 local_free (hash_buf.salt);
12076 }
12077
12078 local_free (hash_buf.digest);
12079 }
12080
12081 /**
12082 * Now generate all the buffers required for later
12083 */
12084
12085 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12086
12087 salt_t *salts_buf_new = NULL;
12088 void *esalts_buf_new = NULL;
12089
12090 if (isSalted)
12091 {
12092 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12093
12094 if (esalt_size)
12095 {
12096 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12097 }
12098 }
12099 else
12100 {
12101 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12102 }
12103
12104 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12105
12106 uint digests_cnt = hashes_cnt;
12107 uint digests_done = 0;
12108
12109 uint size_digests = digests_cnt * dgst_size;
12110 uint size_shown = digests_cnt * sizeof (uint);
12111
12112 uint *digests_shown = (uint *) mymalloc (size_shown);
12113 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12114
12115 uint salts_cnt = 0;
12116 uint salts_done = 0;
12117
12118 hashinfo_t **hash_info = NULL;
12119
12120 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12121 {
12122 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12123
12124 if (username && (remove || show))
12125 {
12126 uint user_pos;
12127
12128 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12129 {
12130 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12131
12132 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12133 }
12134 }
12135 }
12136
12137 uint *salts_shown = (uint *) mymalloc (size_shown);
12138
12139 salt_t *salt_buf;
12140
12141 {
12142 // copied from inner loop
12143
12144 salt_buf = &salts_buf_new[salts_cnt];
12145
12146 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12147
12148 if (esalt_size)
12149 {
12150 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12151 }
12152
12153 salt_buf->digests_cnt = 0;
12154 salt_buf->digests_done = 0;
12155 salt_buf->digests_offset = 0;
12156
12157 salts_cnt++;
12158 }
12159
12160 if (hashes_buf[0].cracked == 1)
12161 {
12162 digests_shown[0] = 1;
12163
12164 digests_done++;
12165
12166 salt_buf->digests_done++;
12167 }
12168
12169 salt_buf->digests_cnt++;
12170
12171 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12172
12173 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12174 {
12175 hash_info[0] = hashes_buf[0].hash_info;
12176 }
12177
12178 // copy from inner loop
12179
12180 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12181 {
12182 if (isSalted)
12183 {
12184 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12185 {
12186 salt_buf = &salts_buf_new[salts_cnt];
12187
12188 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12189
12190 if (esalt_size)
12191 {
12192 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12193 }
12194
12195 salt_buf->digests_cnt = 0;
12196 salt_buf->digests_done = 0;
12197 salt_buf->digests_offset = hashes_pos;
12198
12199 salts_cnt++;
12200 }
12201 }
12202
12203 if (hashes_buf[hashes_pos].cracked == 1)
12204 {
12205 digests_shown[hashes_pos] = 1;
12206
12207 digests_done++;
12208
12209 salt_buf->digests_done++;
12210 }
12211
12212 salt_buf->digests_cnt++;
12213
12214 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12215
12216 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12217 {
12218 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12219 }
12220 }
12221
12222 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12223 {
12224 salt_t *salt_buf = &salts_buf_new[salt_pos];
12225
12226 if (salt_buf->digests_done == salt_buf->digests_cnt)
12227 {
12228 salts_shown[salt_pos] = 1;
12229
12230 salts_done++;
12231 }
12232
12233 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12234 }
12235
12236 local_free (digests_buf);
12237 local_free (salts_buf);
12238 local_free (esalts_buf);
12239
12240 digests_buf = digests_buf_new;
12241 salts_buf = salts_buf_new;
12242 esalts_buf = esalts_buf_new;
12243
12244 local_free (hashes_buf);
12245
12246 /**
12247 * special modification not set from parser
12248 */
12249
12250 switch (hash_mode)
12251 {
12252 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12253 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12254 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12255 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12256 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12257 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12258 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12259 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12260 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12261 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12262 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12263 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12264 }
12265
12266 if (truecrypt_keyfiles)
12267 {
12268 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12269
12270 char *keyfiles = strdup (truecrypt_keyfiles);
12271
12272 char *keyfile = strtok (keyfiles, ",");
12273
12274 do
12275 {
12276 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12277
12278 } while ((keyfile = strtok (NULL, ",")) != NULL);
12279
12280 free (keyfiles);
12281 }
12282
12283 data.digests_cnt = digests_cnt;
12284 data.digests_done = digests_done;
12285 data.digests_buf = digests_buf;
12286 data.digests_shown = digests_shown;
12287 data.digests_shown_tmp = digests_shown_tmp;
12288
12289 data.salts_cnt = salts_cnt;
12290 data.salts_done = salts_done;
12291 data.salts_buf = salts_buf;
12292 data.salts_shown = salts_shown;
12293
12294 data.esalts_buf = esalts_buf;
12295 data.hash_info = hash_info;
12296
12297 /**
12298 * Automatic Optimizers
12299 */
12300
12301 if (salts_cnt == 1)
12302 opti_type |= OPTI_TYPE_SINGLE_SALT;
12303
12304 if (digests_cnt == 1)
12305 opti_type |= OPTI_TYPE_SINGLE_HASH;
12306
12307 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12308 opti_type |= OPTI_TYPE_NOT_ITERATED;
12309
12310 if (attack_mode == ATTACK_MODE_BF)
12311 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12312
12313 data.opti_type = opti_type;
12314
12315 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12316 {
12317 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12318 {
12319 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12320 {
12321 if (opts_type & OPTS_TYPE_ST_ADD80)
12322 {
12323 opts_type &= ~OPTS_TYPE_ST_ADD80;
12324 opts_type |= OPTS_TYPE_PT_ADD80;
12325 }
12326
12327 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12328 {
12329 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12330 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12331 }
12332
12333 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12334 {
12335 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12336 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12337 }
12338 }
12339 }
12340 }
12341
12342 /**
12343 * Some algorithm, like descrypt, can benefit from JIT compilation
12344 */
12345
12346 int force_jit_compilation = -1;
12347
12348 if (hash_mode == 8900)
12349 {
12350 force_jit_compilation = 8900;
12351 }
12352 else if (hash_mode == 9300)
12353 {
12354 force_jit_compilation = 8900;
12355 }
12356 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12357 {
12358 force_jit_compilation = 1500;
12359 }
12360
12361 /**
12362 * generate bitmap tables
12363 */
12364
12365 const uint bitmap_shift1 = 5;
12366 const uint bitmap_shift2 = 13;
12367
12368 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12369
12370 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12371 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12372 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12373 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12374 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12375 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12376 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12377 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12378
12379 uint bitmap_bits;
12380 uint bitmap_nums;
12381 uint bitmap_mask;
12382 uint bitmap_size;
12383
12384 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12385 {
12386 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12387
12388 bitmap_nums = 1 << bitmap_bits;
12389
12390 bitmap_mask = bitmap_nums - 1;
12391
12392 bitmap_size = bitmap_nums * sizeof (uint);
12393
12394 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12395
12396 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;
12397 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;
12398
12399 break;
12400 }
12401
12402 bitmap_nums = 1 << bitmap_bits;
12403
12404 bitmap_mask = bitmap_nums - 1;
12405
12406 bitmap_size = bitmap_nums * sizeof (uint);
12407
12408 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);
12409 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);
12410
12411 /**
12412 * prepare quick rule
12413 */
12414
12415 data.rule_buf_l = rule_buf_l;
12416 data.rule_buf_r = rule_buf_r;
12417
12418 int rule_len_l = (int) strlen (rule_buf_l);
12419 int rule_len_r = (int) strlen (rule_buf_r);
12420
12421 data.rule_len_l = rule_len_l;
12422 data.rule_len_r = rule_len_r;
12423
12424 /**
12425 * load rules
12426 */
12427
12428 uint *all_kernel_rules_cnt = NULL;
12429
12430 kernel_rule_t **all_kernel_rules_buf = NULL;
12431
12432 if (rp_files_cnt)
12433 {
12434 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12435
12436 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12437 }
12438
12439 char rule_buf[BUFSIZ] = { 0 };
12440
12441 int rule_len = 0;
12442
12443 for (uint i = 0; i < rp_files_cnt; i++)
12444 {
12445 uint kernel_rules_avail = 0;
12446
12447 uint kernel_rules_cnt = 0;
12448
12449 kernel_rule_t *kernel_rules_buf = NULL;
12450
12451 char *rp_file = rp_files[i];
12452
12453 char in[BLOCK_SIZE] = { 0 };
12454 char out[BLOCK_SIZE] = { 0 };
12455
12456 FILE *fp = NULL;
12457
12458 uint rule_line = 0;
12459
12460 if ((fp = fopen (rp_file, "rb")) == NULL)
12461 {
12462 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12463
12464 return (-1);
12465 }
12466
12467 while (!feof (fp))
12468 {
12469 memset (rule_buf, 0, BUFSIZ);
12470
12471 rule_len = fgetl (fp, rule_buf);
12472
12473 rule_line++;
12474
12475 if (rule_len == 0) continue;
12476
12477 if (rule_buf[0] == '#') continue;
12478
12479 if (kernel_rules_avail == kernel_rules_cnt)
12480 {
12481 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12482
12483 kernel_rules_avail += INCR_RULES;
12484 }
12485
12486 memset (in, 0, BLOCK_SIZE);
12487 memset (out, 0, BLOCK_SIZE);
12488
12489 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12490
12491 if (result == -1)
12492 {
12493 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12494
12495 continue;
12496 }
12497
12498 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12499 {
12500 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12501
12502 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12503
12504 continue;
12505 }
12506
12507 /* its so slow
12508 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12509 {
12510 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12511
12512 continue;
12513 }
12514 */
12515
12516 kernel_rules_cnt++;
12517 }
12518
12519 fclose (fp);
12520
12521 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12522
12523 all_kernel_rules_buf[i] = kernel_rules_buf;
12524 }
12525
12526 /**
12527 * merge rules or automatic rule generator
12528 */
12529
12530 uint kernel_rules_cnt = 0;
12531
12532 kernel_rule_t *kernel_rules_buf = NULL;
12533
12534 if (attack_mode == ATTACK_MODE_STRAIGHT)
12535 {
12536 if (rp_files_cnt)
12537 {
12538 kernel_rules_cnt = 1;
12539
12540 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12541
12542 repeats[0] = kernel_rules_cnt;
12543
12544 for (uint i = 0; i < rp_files_cnt; i++)
12545 {
12546 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12547
12548 repeats[i + 1] = kernel_rules_cnt;
12549 }
12550
12551 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12552
12553 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12554
12555 for (uint i = 0; i < kernel_rules_cnt; i++)
12556 {
12557 uint out_pos = 0;
12558
12559 kernel_rule_t *out = &kernel_rules_buf[i];
12560
12561 for (uint j = 0; j < rp_files_cnt; j++)
12562 {
12563 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12564 uint in_pos;
12565
12566 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12567
12568 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12569 {
12570 if (out_pos == RULES_MAX - 1)
12571 {
12572 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12573
12574 break;
12575 }
12576
12577 out->cmds[out_pos] = in->cmds[in_pos];
12578 }
12579 }
12580 }
12581
12582 local_free (repeats);
12583 }
12584 else if (rp_gen)
12585 {
12586 uint kernel_rules_avail = 0;
12587
12588 while (kernel_rules_cnt < rp_gen)
12589 {
12590 if (kernel_rules_avail == kernel_rules_cnt)
12591 {
12592 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12593
12594 kernel_rules_avail += INCR_RULES;
12595 }
12596
12597 memset (rule_buf, 0, BLOCK_SIZE);
12598
12599 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12600
12601 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12602
12603 kernel_rules_cnt++;
12604 }
12605 }
12606 }
12607
12608 /**
12609 * generate NOP rules
12610 */
12611
12612 if (kernel_rules_cnt == 0)
12613 {
12614 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12615
12616 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12617
12618 kernel_rules_cnt++;
12619 }
12620
12621 data.kernel_rules_cnt = kernel_rules_cnt;
12622 data.kernel_rules_buf = kernel_rules_buf;
12623
12624 /**
12625 * OpenCL platforms: detect
12626 */
12627
12628 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12629 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12630
12631 cl_uint platforms_cnt = 0;
12632 cl_uint platform_devices_cnt = 0;
12633
12634 if (keyspace == 0)
12635 {
12636 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12637
12638 if (platforms_cnt == 0)
12639 {
12640 log_error ("ERROR: No OpenCL compatible platform found");
12641
12642 return (-1);
12643 }
12644 }
12645
12646 /**
12647 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12648 */
12649
12650 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12651 {
12652 cl_platform_id platform = platforms[platform_id];
12653
12654 char platform_vendor[INFOSZ] = { 0 };
12655
12656 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12657
12658 #ifdef HAVE_HWMON
12659 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12660 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12661 {
12662 // make sure that we do not directly control the fan for NVidia
12663
12664 gpu_temp_retain = 0;
12665
12666 data.gpu_temp_retain = gpu_temp_retain;
12667 }
12668 #endif // HAVE_NVML || HAVE_NVAPI
12669 #endif
12670 }
12671
12672 /**
12673 * OpenCL devices: simply push all devices from all platforms into the same device array
12674 */
12675
12676 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12677
12678 data.devices_param = devices_param;
12679
12680 uint devices_cnt = 0;
12681
12682 uint devices_active = 0;
12683
12684 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12685 {
12686 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12687
12688 cl_platform_id platform = platforms[platform_id];
12689
12690 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12691
12692 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12693 {
12694 size_t param_value_size = 0;
12695
12696 const uint device_id = devices_cnt;
12697
12698 hc_device_param_t *device_param = &data.devices_param[device_id];
12699
12700 device_param->device = platform_devices[platform_devices_id];
12701
12702 device_param->device_id = device_id;
12703
12704 device_param->platform_devices_id = platform_devices_id;
12705
12706 // device_type
12707
12708 cl_device_type device_type;
12709
12710 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12711
12712 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12713
12714 device_param->device_type = device_type;
12715
12716 // vendor_id
12717
12718 cl_uint vendor_id = 0;
12719
12720 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12721
12722 device_param->vendor_id = vendor_id;
12723
12724 // device_name
12725
12726 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12727
12728 char *device_name = (char *) mymalloc (param_value_size);
12729
12730 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12731
12732 device_param->device_name = device_name;
12733
12734 // tuning db
12735
12736 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12737
12738 // device_version
12739
12740 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12741
12742 char *device_version = (char *) mymalloc (param_value_size);
12743
12744 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12745
12746 device_param->device_version = device_version;
12747
12748 // device_opencl_version
12749
12750 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12751
12752 char *device_opencl_version = (char *) mymalloc (param_value_size);
12753
12754 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12755
12756 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12757
12758 myfree (device_opencl_version);
12759
12760 if (strstr (device_version, "pocl"))
12761 {
12762 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12763 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12764
12765 cl_uint vendor_id = VENDOR_ID_GENERIC;
12766
12767 device_param->vendor_id = vendor_id;
12768 }
12769
12770 // vector_width
12771
12772 cl_uint vector_width;
12773
12774 if (opencl_vector_width_chgd == 0)
12775 {
12776 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12777 {
12778 if (opti_type & OPTI_TYPE_USES_BITS_64)
12779 {
12780 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12781 }
12782 else
12783 {
12784 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12785 }
12786 }
12787 else
12788 {
12789 vector_width = (cl_uint) tuningdb_entry->vector_width;
12790 }
12791 }
12792 else
12793 {
12794 vector_width = opencl_vector_width;
12795 }
12796
12797 if (vector_width > 16) vector_width = 16;
12798
12799 device_param->vector_width = vector_width;
12800
12801 // max_compute_units
12802
12803 cl_uint device_processors;
12804
12805 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12806
12807 device_param->device_processors = device_processors;
12808
12809 // max_mem_alloc_size
12810
12811 cl_ulong device_maxmem_alloc;
12812
12813 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12814
12815 device_param->device_maxmem_alloc = device_maxmem_alloc;
12816
12817 // max_mem_alloc_size
12818
12819 cl_ulong device_global_mem;
12820
12821 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12822
12823 device_param->device_global_mem = device_global_mem;
12824
12825 // max_clock_frequency
12826
12827 cl_uint device_maxclock_frequency;
12828
12829 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12830
12831 device_param->device_maxclock_frequency = device_maxclock_frequency;
12832
12833 // skipped
12834
12835 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12836 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12837
12838 device_param->skipped = (skipped1 || skipped2);
12839
12840 // driver_version
12841 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12842
12843 char *driver_version = (char *) mymalloc (param_value_size);
12844
12845 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12846
12847 device_param->driver_version = driver_version;
12848
12849 // device_name_chksum
12850
12851 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12852
12853 #if __x86_64__
12854 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);
12855 #else
12856 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);
12857 #endif
12858
12859 uint device_name_digest[4] = { 0 };
12860
12861 md5_64 ((uint *) device_name_chksum, device_name_digest);
12862
12863 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12864
12865 device_param->device_name_chksum = device_name_chksum;
12866
12867 // device_processor_cores
12868
12869 if (device_type & CL_DEVICE_TYPE_CPU)
12870 {
12871 cl_uint device_processor_cores = 1;
12872
12873 device_param->device_processor_cores = device_processor_cores;
12874 }
12875
12876 if (device_type & CL_DEVICE_TYPE_GPU)
12877 {
12878 if (vendor_id == VENDOR_ID_AMD)
12879 {
12880 cl_uint device_processor_cores = 0;
12881
12882 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12883
12884 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12885
12886 device_param->device_processor_cores = device_processor_cores;
12887 }
12888 else if (vendor_id == VENDOR_ID_NV)
12889 {
12890 cl_uint kernel_exec_timeout = 0;
12891
12892 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12893
12894 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12895
12896 device_param->kernel_exec_timeout = kernel_exec_timeout;
12897
12898 cl_uint device_processor_cores = 0;
12899
12900 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12901
12902 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12903
12904 device_param->device_processor_cores = device_processor_cores;
12905
12906 cl_uint sm_minor = 0;
12907 cl_uint sm_major = 0;
12908
12909 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12910 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12911
12912 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12913 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12914
12915 device_param->sm_minor = sm_minor;
12916 device_param->sm_major = sm_major;
12917 }
12918 else
12919 {
12920 cl_uint device_processor_cores = 1;
12921
12922 device_param->device_processor_cores = device_processor_cores;
12923 }
12924 }
12925
12926 // display results
12927
12928 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12929 {
12930 if (device_param->skipped == 0)
12931 {
12932 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12933 device_id + 1,
12934 device_name,
12935 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12936 (unsigned int) (device_global_mem / 1024 / 1024),
12937 (unsigned int) (device_maxclock_frequency),
12938 (unsigned int) device_processors);
12939 }
12940 else
12941 {
12942 log_info ("Device #%u: %s, skipped",
12943 device_id + 1,
12944 device_name);
12945 }
12946 }
12947
12948 // common driver check
12949
12950 if (device_param->skipped == 0)
12951 {
12952 if (strstr (device_version, "pocl"))
12953 {
12954 if (force == 0)
12955 {
12956 log_info ("");
12957 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12958 log_info ("You are STRONGLY encouraged not to use it");
12959 log_info ("You can use --force to override this but do not post error reports if you do so");
12960 log_info ("");
12961
12962 return (-1);
12963 }
12964 }
12965
12966 if (device_type & CL_DEVICE_TYPE_GPU)
12967 {
12968 if (vendor_id == VENDOR_ID_NV)
12969 {
12970 if (device_param->kernel_exec_timeout != 0)
12971 {
12972 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);
12973 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12974 }
12975 }
12976 else if (vendor_id == VENDOR_ID_AMD)
12977 {
12978 int catalyst_check = (force == 1) ? 0 : 1;
12979
12980 int catalyst_warn = 0;
12981
12982 int catalyst_broken = 0;
12983
12984 if (catalyst_check == 1)
12985 {
12986 catalyst_warn = 1;
12987
12988 // v14.9 and higher
12989 if (atoi (device_param->driver_version) >= 1573)
12990 {
12991 catalyst_warn = 0;
12992 }
12993
12994 catalyst_check = 0;
12995 }
12996
12997 if (catalyst_broken == 1)
12998 {
12999 log_info ("");
13000 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13001 log_info ("It will pass over cracked hashes and does not report them as cracked");
13002 log_info ("You are STRONGLY encouraged not to use it");
13003 log_info ("You can use --force to override this but do not post error reports if you do so");
13004 log_info ("");
13005
13006 return (-1);
13007 }
13008
13009 if (catalyst_warn == 1)
13010 {
13011 log_info ("");
13012 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13013 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13014 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13015 #ifdef _WIN
13016 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13017 #endif
13018 log_info ("You can use --force to override this but do not post error reports if you do so");
13019 log_info ("");
13020
13021 return (-1);
13022 }
13023 }
13024 }
13025
13026 /**
13027 * kernel accel and loops tuning db adjustment
13028 */
13029
13030 device_param->kernel_accel_min = 1;
13031 device_param->kernel_accel_max = 1024;
13032
13033 device_param->kernel_loops_min = 1;
13034 device_param->kernel_loops_max = 1024;
13035
13036 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13037
13038 if (tuningdb_entry)
13039 {
13040 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13041 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13042
13043 if (_kernel_accel)
13044 {
13045 device_param->kernel_accel_min = _kernel_accel;
13046 device_param->kernel_accel_max = _kernel_accel;
13047 }
13048
13049 if (_kernel_loops)
13050 {
13051 if (workload_profile == 1)
13052 {
13053 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13054 }
13055 else if (workload_profile == 2)
13056 {
13057 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13058 }
13059
13060 device_param->kernel_loops_min = _kernel_loops;
13061 device_param->kernel_loops_max = _kernel_loops;
13062 }
13063 }
13064
13065 // commandline parameters overwrite tuningdb entries
13066
13067 if (kernel_accel)
13068 {
13069 device_param->kernel_accel_min = kernel_accel;
13070 device_param->kernel_accel_max = kernel_accel;
13071 }
13072
13073 if (kernel_loops)
13074 {
13075 device_param->kernel_loops_min = kernel_loops;
13076 device_param->kernel_loops_max = kernel_loops;
13077 }
13078
13079 /**
13080 * activate device
13081 */
13082
13083 devices_active++;
13084 }
13085
13086 // next please
13087
13088 devices_cnt++;
13089 }
13090 }
13091
13092 if (keyspace == 0 && devices_active == 0)
13093 {
13094 log_error ("ERROR: No devices found/left");
13095
13096 return (-1);
13097 }
13098
13099 data.devices_cnt = devices_cnt;
13100
13101 data.devices_active = devices_active;
13102
13103 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13104 {
13105 log_info ("");
13106 }
13107
13108 /**
13109 * HM devices: init
13110 */
13111
13112 #ifdef HAVE_HWMON
13113 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13114 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13115 #endif
13116
13117 #ifdef HAVE_ADL
13118 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13119 #endif
13120
13121 if (gpu_temp_disable == 0)
13122 {
13123 #if defined(WIN) && defined(HAVE_NVAPI)
13124 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13125
13126 if (nvapi_init (nvapi) == 0)
13127 data.hm_nv = nvapi;
13128
13129 if (data.hm_nv)
13130 {
13131 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13132 {
13133 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13134
13135 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13136
13137 int tmp_out = 0;
13138
13139 for (int i = 0; i < tmp_in; i++)
13140 {
13141 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13142 }
13143
13144 for (int i = 0; i < tmp_out; i++)
13145 {
13146 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13147
13148 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13149
13150 if (hm_NvAPI_GPU_GetCoolerSettings (data.hm_nv, hm_adapters_nv[i].adapter_index.nv, 0, &pCoolerSettings) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13151 }
13152 }
13153 }
13154 #endif // WIN && HAVE_NVAPI
13155
13156 #if defined(LINUX) && defined(HAVE_NVML)
13157 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13158
13159 if (nvml_init (nvml) == 0)
13160 data.hm_nv = nvml;
13161
13162 if (data.hm_nv)
13163 {
13164 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13165 {
13166 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13167
13168 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13169
13170 int tmp_out = 0;
13171
13172 for (int i = 0; i < tmp_in; i++)
13173 {
13174 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13175 }
13176
13177 for (int i = 0; i < tmp_out; i++)
13178 {
13179 unsigned int speed;
13180
13181 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13182 }
13183 }
13184 }
13185 #endif // LINUX && HAVE_NVML
13186
13187 data.hm_amd = NULL;
13188
13189 #ifdef HAVE_ADL
13190 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13191
13192 if (adl_init (adl) == 0)
13193 data.hm_amd = adl;
13194
13195 if (data.hm_amd)
13196 {
13197 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13198 {
13199 // total number of adapters
13200
13201 int hm_adapters_num;
13202
13203 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13204
13205 // adapter info
13206
13207 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13208
13209 if (lpAdapterInfo == NULL) return (-1);
13210
13211 // get a list (of ids of) valid/usable adapters
13212
13213 int num_adl_adapters = 0;
13214
13215 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13216
13217 if (num_adl_adapters > 0)
13218 {
13219 hc_thread_mutex_lock (mux_adl);
13220
13221 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13222
13223 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13224
13225 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13226 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13227
13228 hc_thread_mutex_unlock (mux_adl);
13229 }
13230
13231 myfree (valid_adl_device_list);
13232 myfree (lpAdapterInfo);
13233 }
13234 }
13235 #endif // HAVE_ADL
13236
13237 if (data.hm_amd == NULL && data.hm_nv == NULL)
13238 {
13239 gpu_temp_disable = 1;
13240 }
13241 }
13242
13243 /**
13244 * OpenCL devices: allocate buffer for device specific information
13245 */
13246
13247 #ifdef HAVE_HWMON
13248 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13249
13250 #ifdef HAVE_ADL
13251 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13252
13253 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13254 #endif // ADL
13255 #endif
13256
13257 /**
13258 * enable custom signal handler(s)
13259 */
13260
13261 if (benchmark == 0)
13262 {
13263 hc_signal (sigHandler_default);
13264 }
13265 else
13266 {
13267 hc_signal (sigHandler_benchmark);
13268 }
13269
13270 /**
13271 * User-defined GPU temp handling
13272 */
13273
13274 #ifdef HAVE_HWMON
13275 if (gpu_temp_disable == 1)
13276 {
13277 gpu_temp_abort = 0;
13278 gpu_temp_retain = 0;
13279 }
13280
13281 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13282 {
13283 if (gpu_temp_abort < gpu_temp_retain)
13284 {
13285 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13286
13287 return (-1);
13288 }
13289 }
13290
13291 data.gpu_temp_disable = gpu_temp_disable;
13292 data.gpu_temp_abort = gpu_temp_abort;
13293 data.gpu_temp_retain = gpu_temp_retain;
13294 #endif
13295
13296 /**
13297 * inform the user
13298 */
13299
13300 if (data.quiet == 0)
13301 {
13302 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13303
13304 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);
13305
13306 if (attack_mode == ATTACK_MODE_STRAIGHT)
13307 {
13308 log_info ("Rules: %u", kernel_rules_cnt);
13309 }
13310
13311 if (opti_type)
13312 {
13313 log_info ("Applicable Optimizers:");
13314
13315 for (uint i = 0; i < 32; i++)
13316 {
13317 const uint opti_bit = 1u << i;
13318
13319 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13320 }
13321 }
13322
13323 /**
13324 * Watchdog and Temperature balance
13325 */
13326
13327 #ifdef HAVE_HWMON
13328 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13329 {
13330 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13331 }
13332
13333 if (gpu_temp_abort == 0)
13334 {
13335 log_info ("Watchdog: Temperature abort trigger disabled");
13336 }
13337 else
13338 {
13339 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13340 }
13341
13342 if (gpu_temp_retain == 0)
13343 {
13344 log_info ("Watchdog: Temperature retain trigger disabled");
13345 }
13346 else
13347 {
13348 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13349 }
13350 #endif
13351 }
13352
13353 if (data.quiet == 0) log_info ("");
13354
13355 /**
13356 * HM devices: copy
13357 */
13358
13359 if (gpu_temp_disable == 0)
13360 {
13361 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13362 {
13363 hc_device_param_t *device_param = &data.devices_param[device_id];
13364
13365 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13366
13367 if (device_param->skipped) continue;
13368
13369 const uint platform_devices_id = device_param->platform_devices_id;
13370
13371 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13372 if (device_param->vendor_id == VENDOR_ID_NV)
13373 {
13374 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13375 }
13376 #endif
13377
13378 #ifdef HAVE_ADL
13379 if (device_param->vendor_id == VENDOR_ID_AMD)
13380 {
13381 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13382 }
13383 #endif
13384 }
13385 }
13386
13387 /*
13388 * Temporary fix:
13389 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13390 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13391 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13392 * Driver / ADL bug?
13393 */
13394
13395 #ifdef HAVE_ADL
13396 if (powertune_enable == 1)
13397 {
13398 hc_thread_mutex_lock (mux_adl);
13399
13400 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13401 {
13402 hc_device_param_t *device_param = &data.devices_param[device_id];
13403
13404 if (device_param->skipped) continue;
13405
13406 if (data.hm_device[device_id].od_version == 6)
13407 {
13408 // set powertune value only
13409
13410 int powertune_supported = 0;
13411
13412 int ADL_rc = 0;
13413
13414 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13415 {
13416 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13417
13418 return (-1);
13419 }
13420
13421 if (powertune_supported != 0)
13422 {
13423 // powertune set
13424 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13425
13426 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13427 {
13428 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13429
13430 return (-1);
13431 }
13432
13433 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13434 {
13435 log_error ("ERROR: Failed to set new ADL PowerControl values");
13436
13437 return (-1);
13438 }
13439 }
13440 }
13441 }
13442
13443 hc_thread_mutex_unlock (mux_adl);
13444 }
13445 #endif // HAVE_ADK
13446 #endif // HAVE_HWMON
13447
13448 #ifdef DEBUG
13449 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13450 #endif
13451
13452 uint kernel_power_all = 0;
13453
13454 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13455 {
13456 /**
13457 * host buffer
13458 */
13459
13460 hc_device_param_t *device_param = &data.devices_param[device_id];
13461
13462 if (device_param->skipped) continue;
13463
13464 /**
13465 * device properties
13466 */
13467
13468 const char *device_name_chksum = device_param->device_name_chksum;
13469 const u32 device_processors = device_param->device_processors;
13470 const u32 device_processor_cores = device_param->device_processor_cores;
13471
13472 /**
13473 * create context for each device
13474 */
13475
13476 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13477
13478 /**
13479 * create command-queue
13480 */
13481
13482 // not supported with NV
13483 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13484
13485 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13486
13487 /**
13488 * create input buffers on device : calculate size of fixed memory buffers
13489 */
13490
13491 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13492 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13493
13494 device_param->size_root_css = size_root_css;
13495 device_param->size_markov_css = size_markov_css;
13496
13497 uint size_results = KERNEL_THREADS * sizeof (uint);
13498
13499 device_param->size_results = size_results;
13500
13501 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13502 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13503
13504 uint size_plains = digests_cnt * sizeof (plain_t);
13505 uint size_salts = salts_cnt * sizeof (salt_t);
13506 uint size_esalts = salts_cnt * esalt_size;
13507
13508 device_param->size_plains = size_plains;
13509 device_param->size_digests = size_digests;
13510 device_param->size_shown = size_shown;
13511 device_param->size_salts = size_salts;
13512
13513 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13514 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13515 uint size_tm = 32 * sizeof (bs_word_t);
13516
13517 // scryptV stuff
13518
13519 u64 size_scryptV = 1;
13520
13521 if ((hash_mode == 8900) || (hash_mode == 9300))
13522 {
13523 uint tmto_start = 0;
13524 uint tmto_stop = 10;
13525
13526 if (scrypt_tmto)
13527 {
13528 tmto_start = scrypt_tmto;
13529 }
13530 else
13531 {
13532 // in case the user did not specify the tmto manually
13533 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13534 // but set the lower end only in case the user has a device with too less memory
13535
13536 if (hash_mode == 8900)
13537 {
13538 if (device_param->vendor_id == VENDOR_ID_AMD)
13539 {
13540 tmto_start = 1;
13541 }
13542 else if (device_param->vendor_id == VENDOR_ID_NV)
13543 {
13544 tmto_start = 3;
13545 }
13546 }
13547 else if (hash_mode == 9300)
13548 {
13549 if (device_param->vendor_id == VENDOR_ID_AMD)
13550 {
13551 tmto_start = 3;
13552 }
13553 else if (device_param->vendor_id == VENDOR_ID_NV)
13554 {
13555 tmto_start = 5;
13556 }
13557 }
13558 }
13559
13560 if (quiet == 0) log_info ("");
13561
13562 uint shader_per_mp = 1;
13563
13564 if (device_param->vendor_id == VENDOR_ID_AMD)
13565 {
13566 shader_per_mp = 8;
13567 }
13568 else if (device_param->vendor_id == VENDOR_ID_NV)
13569 {
13570 shader_per_mp = 32;
13571 }
13572
13573 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13574 {
13575 // TODO: in theory the following calculation needs to be done per salt, not global
13576 // we assume all hashes have the same scrypt settings
13577
13578 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13579
13580 size_scryptV /= 1 << tmto;
13581
13582 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13583
13584 if (size_scryptV > device_param->device_maxmem_alloc)
13585 {
13586 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13587
13588 continue;
13589 }
13590
13591 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13592 {
13593 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13594 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13595 }
13596
13597 break;
13598 }
13599
13600 if (data.salts_buf[0].scrypt_phy == 0)
13601 {
13602 log_error ("ERROR: can't allocate enough device memory");
13603
13604 return -1;
13605 }
13606
13607 if (quiet == 0) log_info ("");
13608 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13609 }
13610
13611 /**
13612 * create input buffers on device : calculate size of dynamic size memory buffers
13613 */
13614
13615 uint kernel_threads = KERNEL_THREADS;
13616
13617 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13618
13619 if (hash_mode == 3200) kernel_threads = 8;
13620 if (hash_mode == 9000) kernel_threads = 8;
13621
13622 /**
13623 * some algorithms need a fixed kernel-loops count
13624 */
13625
13626 if (hash_mode == 1500)
13627 {
13628 const u32 kernel_loops_fixed = 1024;
13629
13630 device_param->kernel_loops_min = kernel_loops_fixed;
13631 device_param->kernel_loops_max = kernel_loops_fixed;
13632 }
13633
13634 if (hash_mode == 3000)
13635 {
13636 const u32 kernel_loops_fixed = 1024;
13637
13638 device_param->kernel_loops_min = kernel_loops_fixed;
13639 device_param->kernel_loops_max = kernel_loops_fixed;
13640 }
13641
13642 if (hash_mode == 8900)
13643 {
13644 const u32 kernel_loops_fixed = 1;
13645
13646 device_param->kernel_loops_min = kernel_loops_fixed;
13647 device_param->kernel_loops_max = kernel_loops_fixed;
13648 }
13649
13650 if (hash_mode == 9300)
13651 {
13652 const u32 kernel_loops_fixed = 1;
13653
13654 device_param->kernel_loops_min = kernel_loops_fixed;
13655 device_param->kernel_loops_max = kernel_loops_fixed;
13656 }
13657
13658 if (hash_mode == 12500)
13659 {
13660 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13661
13662 device_param->kernel_loops_min = kernel_loops_fixed;
13663 device_param->kernel_loops_max = kernel_loops_fixed;
13664 }
13665
13666 /**
13667 * some algorithms have a maximum kernel-loops count
13668 */
13669
13670 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13671 {
13672 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13673 {
13674 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13675 }
13676 }
13677
13678 /**
13679 * some algorithms need a special kernel-accel
13680 */
13681
13682 if (hash_mode == 8900)
13683 {
13684 device_param->kernel_accel_min = 1;
13685 device_param->kernel_accel_max = 64;
13686 }
13687
13688 if (hash_mode == 9300)
13689 {
13690 device_param->kernel_accel_min = 1;
13691 device_param->kernel_accel_max = 64;
13692 }
13693
13694 u32 kernel_accel_min = device_param->kernel_accel_min;
13695 u32 kernel_accel_max = device_param->kernel_accel_max;
13696
13697 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13698
13699 uint size_pws = 4;
13700 uint size_tmps = 4;
13701 uint size_hooks = 4;
13702
13703 while (kernel_accel_max >= kernel_accel_min)
13704 {
13705 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13706
13707 // size_pws
13708
13709 size_pws = kernel_power_max * sizeof (pw_t);
13710
13711 // size_tmps
13712
13713 switch (hash_mode)
13714 {
13715 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13716 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13717 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13718 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13719 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13720 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13721 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13722 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13723 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13724 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13725 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13726 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13727 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13728 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13729 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13730 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13731 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13732 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13733 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13734 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13735 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13736 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13737 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13738 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13739 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13740 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13741 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13742 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13743 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13744 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13745 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13746 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13747 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13748 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13749 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13750 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13751 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13752 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13753 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13754 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13755 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13756 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13757 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13758 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13759 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13760 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13761 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13762 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13763 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13764 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13765 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13766 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13767 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13768 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13769 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13770 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13771 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13772 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13773 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13774 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13775 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13776 };
13777
13778 // size_hooks
13779
13780 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13781 {
13782 // none yet
13783 }
13784
13785 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13786 // if not, decrease amplifier and try again
13787
13788 int skip = 0;
13789
13790 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13791 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13792 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13793
13794 if (( bitmap_size
13795 + bitmap_size
13796 + bitmap_size
13797 + bitmap_size
13798 + bitmap_size
13799 + bitmap_size
13800 + bitmap_size
13801 + bitmap_size
13802 + size_bfs
13803 + size_combs
13804 + size_digests
13805 + size_esalts
13806 + size_hooks
13807 + size_markov_css
13808 + size_plains
13809 + size_pws
13810 + size_results
13811 + size_root_css
13812 + size_rules
13813 + size_rules_c
13814 + size_salts
13815 + size_scryptV
13816 + size_shown
13817 + size_tm
13818 + size_tmps) > device_param->device_global_mem) skip = 1;
13819
13820 if (skip == 1)
13821 {
13822 kernel_accel_max--;
13823
13824 continue;
13825 }
13826
13827 break;
13828 }
13829
13830 /*
13831 if (kernel_accel_max == 0)
13832 {
13833 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13834
13835 return -1;
13836 }
13837 */
13838
13839 device_param->kernel_accel_min = kernel_accel_min;
13840 device_param->kernel_accel_max = kernel_accel_max;
13841
13842 /*
13843 if (kernel_accel_max < kernel_accel)
13844 {
13845 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13846
13847 device_param->kernel_accel = kernel_accel_max;
13848 }
13849 */
13850
13851 device_param->size_pws = size_pws;
13852 device_param->size_tmps = size_tmps;
13853 device_param->size_hooks = size_hooks;
13854
13855 // do not confuse kernel_accel_max with kernel_accel here
13856
13857 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13858
13859 device_param->kernel_threads = kernel_threads;
13860 device_param->kernel_power_user = kernel_power;
13861
13862 kernel_power_all += kernel_power;
13863
13864 /**
13865 * default building options
13866 */
13867
13868 char build_opts[1024] = { 0 };
13869
13870 // we don't have sm_* on vendors not NV but it doesn't matter
13871
13872 snprintf (build_opts, sizeof (build_opts) - 1, "-I%s/ -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type);
13873
13874 /**
13875 * main kernel
13876 */
13877
13878 {
13879 /**
13880 * kernel source filename
13881 */
13882
13883 char source_file[256] = { 0 };
13884
13885 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13886
13887 struct stat sst;
13888
13889 if (stat (source_file, &sst) == -1)
13890 {
13891 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13892
13893 return -1;
13894 }
13895
13896 /**
13897 * kernel cached filename
13898 */
13899
13900 char cached_file[256] = { 0 };
13901
13902 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13903
13904 int cached = 1;
13905
13906 struct stat cst;
13907
13908 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13909 {
13910 cached = 0;
13911 }
13912
13913 /**
13914 * kernel compile or load
13915 */
13916
13917 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13918
13919 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13920
13921 if (force_jit_compilation == -1)
13922 {
13923 if (cached == 0)
13924 {
13925 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13926
13927 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13928
13929 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13930
13931 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13932
13933 if (rc != 0)
13934 {
13935 device_param->skipped = true;
13936 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13937 continue;
13938 }
13939
13940 size_t binary_size;
13941
13942 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13943
13944 u8 *binary = (u8 *) mymalloc (binary_size);
13945
13946 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13947
13948 writeProgramBin (cached_file, binary, binary_size);
13949
13950 local_free (binary);
13951 }
13952 else
13953 {
13954 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13955
13956 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13957
13958 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13959
13960 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13961 }
13962 }
13963 else
13964 {
13965 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13966
13967 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13968
13969 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13970
13971 char build_opts_update[1024] = { 0 };
13972
13973 if (force_jit_compilation == 1500)
13974 {
13975 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13976 }
13977 else if (force_jit_compilation == 8900)
13978 {
13979 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%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);
13980 }
13981
13982 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13983
13984 if (rc != 0)
13985 {
13986 device_param->skipped = true;
13987 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13988 }
13989 }
13990
13991 local_free (kernel_lengths);
13992 local_free (kernel_sources[0]);
13993 local_free (kernel_sources);
13994 }
13995
13996 /**
13997 * word generator kernel
13998 */
13999
14000 if (attack_mode != ATTACK_MODE_STRAIGHT)
14001 {
14002 /**
14003 * kernel mp source filename
14004 */
14005
14006 char source_file[256] = { 0 };
14007
14008 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14009
14010 struct stat sst;
14011
14012 if (stat (source_file, &sst) == -1)
14013 {
14014 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14015
14016 return -1;
14017 }
14018
14019 /**
14020 * kernel mp cached filename
14021 */
14022
14023 char cached_file[256] = { 0 };
14024
14025 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14026
14027 int cached = 1;
14028
14029 struct stat cst;
14030
14031 if (stat (cached_file, &cst) == -1)
14032 {
14033 cached = 0;
14034 }
14035
14036 /**
14037 * kernel compile or load
14038 */
14039
14040 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14041
14042 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14043
14044 if (cached == 0)
14045 {
14046 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14047
14048 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14049
14050 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14051
14052 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14053
14054 if (rc != 0)
14055 {
14056 device_param->skipped = true;
14057 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14058 continue;
14059 }
14060
14061 size_t binary_size;
14062
14063 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14064
14065 u8 *binary = (u8 *) mymalloc (binary_size);
14066
14067 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14068
14069 writeProgramBin (cached_file, binary, binary_size);
14070
14071 local_free (binary);
14072 }
14073 else
14074 {
14075 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14076
14077 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14078
14079 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14080
14081 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14082 }
14083
14084 local_free (kernel_lengths);
14085 local_free (kernel_sources[0]);
14086 local_free (kernel_sources);
14087 }
14088
14089 /**
14090 * amplifier kernel
14091 */
14092
14093 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14094 {
14095
14096 }
14097 else
14098 {
14099 /**
14100 * kernel amp source filename
14101 */
14102
14103 char source_file[256] = { 0 };
14104
14105 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14106
14107 struct stat sst;
14108
14109 if (stat (source_file, &sst) == -1)
14110 {
14111 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14112
14113 return -1;
14114 }
14115
14116 /**
14117 * kernel amp cached filename
14118 */
14119
14120 char cached_file[256] = { 0 };
14121
14122 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14123
14124 int cached = 1;
14125
14126 struct stat cst;
14127
14128 if (stat (cached_file, &cst) == -1)
14129 {
14130 cached = 0;
14131 }
14132
14133 /**
14134 * kernel compile or load
14135 */
14136
14137 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14138
14139 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14140
14141 if (cached == 0)
14142 {
14143 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14144
14145 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14146
14147 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14148
14149 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14150
14151 if (rc != 0)
14152 {
14153 device_param->skipped = true;
14154 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14155 continue;
14156 }
14157
14158 size_t binary_size;
14159
14160 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14161
14162 u8 *binary = (u8 *) mymalloc (binary_size);
14163
14164 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14165
14166 writeProgramBin (cached_file, binary, binary_size);
14167
14168 local_free (binary);
14169 }
14170 else
14171 {
14172 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14173
14174 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14175
14176 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14177
14178 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14179 }
14180
14181 local_free (kernel_lengths);
14182 local_free (kernel_sources[0]);
14183 local_free (kernel_sources);
14184 }
14185
14186 // some algorithm collide too fast, make that impossible
14187
14188 if (benchmark == 1)
14189 {
14190 ((uint *) digests_buf)[0] = -1;
14191 ((uint *) digests_buf)[1] = -1;
14192 ((uint *) digests_buf)[2] = -1;
14193 ((uint *) digests_buf)[3] = -1;
14194 }
14195
14196 /**
14197 * global buffers
14198 */
14199
14200 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14201 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14202 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14203 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14204 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14205 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14206 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14207 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14208 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14209 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14210 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14211 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14212 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14213 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14214 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14215 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14216 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14217 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14218
14219 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
14220 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
14221 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
14222 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
14223 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
14224 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
14225 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
14226 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
14227 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14228 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14229 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14230
14231 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14232 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14233 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14234 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14235 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14236 run_kernel_bzero (device_param, device_param->d_result, size_results);
14237
14238 /**
14239 * special buffers
14240 */
14241
14242 if (attack_kern == ATTACK_KERN_STRAIGHT)
14243 {
14244 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14245 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14246
14247 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14248
14249 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14250 }
14251 else if (attack_kern == ATTACK_KERN_COMBI)
14252 {
14253 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14254 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14255 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14256 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14257
14258 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14259 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14260 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14261 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14262 }
14263 else if (attack_kern == ATTACK_KERN_BF)
14264 {
14265 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14266 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14267 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14268 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14269 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14270
14271 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14272 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14273 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14274 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14275 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14276 }
14277
14278 if (size_esalts)
14279 {
14280 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14281
14282 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14283 }
14284
14285 /**
14286 * main host data
14287 */
14288
14289 uint *result = (uint *) mymalloc (size_results);
14290
14291 device_param->result = result;
14292
14293 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14294
14295 device_param->pws_buf = pws_buf;
14296
14297 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
14298
14299 for (int i = 0; i < 64; i++)
14300 {
14301 pw_caches[i].pw_buf.pw_len = i;
14302 pw_caches[i].cnt = 0;
14303 }
14304
14305 device_param->pw_caches = pw_caches;
14306
14307 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14308
14309 device_param->combs_buf = combs_buf;
14310
14311 void *hooks_buf = mymalloc (size_hooks);
14312
14313 device_param->hooks_buf = hooks_buf;
14314
14315 device_param->pw_transpose = pw_transpose_to_hi1;
14316 device_param->pw_add = pw_add_to_hc1;
14317
14318 /**
14319 * kernel args
14320 */
14321
14322 device_param->kernel_params_buf32[21] = bitmap_mask;
14323 device_param->kernel_params_buf32[22] = bitmap_shift1;
14324 device_param->kernel_params_buf32[23] = bitmap_shift2;
14325 device_param->kernel_params_buf32[24] = 0; // salt_pos
14326 device_param->kernel_params_buf32[25] = 0; // loop_pos
14327 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14328 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14329 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14330 device_param->kernel_params_buf32[29] = 0; // digests_offset
14331 device_param->kernel_params_buf32[30] = 0; // combs_mode
14332 device_param->kernel_params_buf32[31] = 0; // gid_max
14333
14334 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14335 ? &device_param->d_pws_buf
14336 : &device_param->d_pws_amp_buf;
14337 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14338 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14339 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14340 device_param->kernel_params[ 4] = &device_param->d_tmps;
14341 device_param->kernel_params[ 5] = &device_param->d_hooks;
14342 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14343 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14344 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14345 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14346 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14347 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14348 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14349 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14350 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14351 device_param->kernel_params[15] = &device_param->d_digests_buf;
14352 device_param->kernel_params[16] = &device_param->d_digests_shown;
14353 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14354 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14355 device_param->kernel_params[19] = &device_param->d_result;
14356 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14357 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14358 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14359 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14360 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14361 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14362 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14363 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14364 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14365 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14366 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14367 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14368
14369 device_param->kernel_params_mp_buf64[3] = 0;
14370 device_param->kernel_params_mp_buf32[4] = 0;
14371 device_param->kernel_params_mp_buf32[5] = 0;
14372 device_param->kernel_params_mp_buf32[6] = 0;
14373 device_param->kernel_params_mp_buf32[7] = 0;
14374 device_param->kernel_params_mp_buf32[8] = 0;
14375
14376 device_param->kernel_params_mp[0] = NULL;
14377 device_param->kernel_params_mp[1] = NULL;
14378 device_param->kernel_params_mp[2] = NULL;
14379 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14380 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14381 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14382 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14383 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14384 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14385
14386 device_param->kernel_params_mp_l_buf64[3] = 0;
14387 device_param->kernel_params_mp_l_buf32[4] = 0;
14388 device_param->kernel_params_mp_l_buf32[5] = 0;
14389 device_param->kernel_params_mp_l_buf32[6] = 0;
14390 device_param->kernel_params_mp_l_buf32[7] = 0;
14391 device_param->kernel_params_mp_l_buf32[8] = 0;
14392 device_param->kernel_params_mp_l_buf32[9] = 0;
14393
14394 device_param->kernel_params_mp_l[0] = NULL;
14395 device_param->kernel_params_mp_l[1] = NULL;
14396 device_param->kernel_params_mp_l[2] = NULL;
14397 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14398 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14399 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14400 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14401 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14402 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14403 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14404
14405 device_param->kernel_params_mp_r_buf64[3] = 0;
14406 device_param->kernel_params_mp_r_buf32[4] = 0;
14407 device_param->kernel_params_mp_r_buf32[5] = 0;
14408 device_param->kernel_params_mp_r_buf32[6] = 0;
14409 device_param->kernel_params_mp_r_buf32[7] = 0;
14410 device_param->kernel_params_mp_r_buf32[8] = 0;
14411
14412 device_param->kernel_params_mp_r[0] = NULL;
14413 device_param->kernel_params_mp_r[1] = NULL;
14414 device_param->kernel_params_mp_r[2] = NULL;
14415 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14416 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14417 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14418 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14419 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14420 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14421
14422 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14423 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14424
14425 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14426 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14427 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14428 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14429 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14430 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14431 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14432
14433 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14434
14435 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14436 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14437
14438 /**
14439 * kernel name
14440 */
14441
14442 char kernel_name[64] = { 0 };
14443
14444 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14445 {
14446 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14447 {
14448 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14449
14450 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14451
14452 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14453
14454 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14455
14456 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14457
14458 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14459 }
14460 else
14461 {
14462 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14463
14464 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14465
14466 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14467
14468 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14469
14470 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14471
14472 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14473 }
14474
14475 if (data.attack_mode == ATTACK_MODE_BF)
14476 {
14477 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14478 {
14479 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14480
14481 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14482
14483 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14484
14485 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14486 }
14487 }
14488 }
14489 else
14490 {
14491 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14492
14493 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14494
14495 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14496
14497 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14498
14499 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14500
14501 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14502
14503 if (opts_type & OPTS_TYPE_HOOK12)
14504 {
14505 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14506
14507 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14508 }
14509
14510 if (opts_type & OPTS_TYPE_HOOK23)
14511 {
14512 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14513
14514 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14515 }
14516 }
14517
14518 for (uint i = 0; i <= 20; i++)
14519 {
14520 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14521 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14522 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14523
14524 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14525 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14526 }
14527
14528 for (uint i = 21; i <= 31; i++)
14529 {
14530 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14531 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14532 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14533
14534 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14535 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14536 }
14537
14538 if (attack_mode == ATTACK_MODE_BF)
14539 {
14540 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14541 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14542
14543 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14544 {
14545 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14546
14547 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14548 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14549 }
14550 }
14551 else if (attack_mode == ATTACK_MODE_HYBRID1)
14552 {
14553 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14554 }
14555 else if (attack_mode == ATTACK_MODE_HYBRID2)
14556 {
14557 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14558 }
14559
14560 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14561 {
14562 // nothing to do
14563 }
14564 else
14565 {
14566 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14567 }
14568
14569 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14570 {
14571 // nothing to do
14572 }
14573 else
14574 {
14575 for (uint i = 0; i < 5; i++)
14576 {
14577 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14578 }
14579
14580 for (uint i = 5; i < 7; i++)
14581 {
14582 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14583 }
14584 }
14585
14586 /**
14587 * Store initial fanspeed if gpu_temp_retain is enabled
14588 */
14589
14590 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14591 int gpu_temp_retain_set = 0;
14592
14593 if (gpu_temp_disable == 0)
14594 {
14595 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14596 {
14597 hc_thread_mutex_lock (mux_adl);
14598
14599 if (data.hm_device[device_id].fan_supported == 1)
14600 {
14601 if (gpu_temp_retain_chgd == 0)
14602 {
14603 uint cur_temp = 0;
14604 uint default_temp = 0;
14605
14606 int ADL_rc = hm_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
14607
14608 if (ADL_rc == ADL_OK)
14609 {
14610 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14611
14612 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14613
14614 // special case with multi gpu setups: always use minimum retain
14615
14616 if (gpu_temp_retain_set == 0)
14617 {
14618 gpu_temp_retain = gpu_temp_retain_target;
14619 gpu_temp_retain_set = 1;
14620 }
14621 else
14622 {
14623 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14624 }
14625
14626 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14627 }
14628 }
14629
14630 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14631
14632 temp_retain_fanspeed_value[device_id] = fan_speed;
14633
14634 if (fan_speed == -1)
14635 {
14636 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14637
14638 temp_retain_fanspeed_value[device_id] = 0;
14639 }
14640 }
14641
14642 hc_thread_mutex_unlock (mux_adl);
14643 }
14644 }
14645
14646 /**
14647 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14648 */
14649
14650 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14651 {
14652 hc_thread_mutex_lock (mux_adl);
14653
14654 if (data.hm_device[device_id].od_version == 6)
14655 {
14656 int ADL_rc;
14657
14658 // check powertune capabilities first, if not available then skip device
14659
14660 int powertune_supported = 0;
14661
14662 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14663 {
14664 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14665
14666 return (-1);
14667 }
14668
14669 if (powertune_supported != 0)
14670 {
14671 // powercontrol settings
14672
14673 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14674
14675 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14676 {
14677 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14678 }
14679
14680 if (ADL_rc != ADL_OK)
14681 {
14682 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14683
14684 return (-1);
14685 }
14686
14687 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14688 {
14689 log_error ("ERROR: Failed to set new ADL PowerControl values");
14690
14691 return (-1);
14692 }
14693
14694 // clocks
14695
14696 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14697
14698 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14699
14700 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14701 {
14702 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14703
14704 return (-1);
14705 }
14706
14707 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14708
14709 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14710
14711 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14712 {
14713 log_error ("ERROR: Failed to get ADL device capabilities");
14714
14715 return (-1);
14716 }
14717
14718 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14719 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14720
14721 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14722 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14723
14724 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14725 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14726
14727 // warning if profile has too low max values
14728
14729 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14730 {
14731 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14732 }
14733
14734 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14735 {
14736 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14737 }
14738
14739 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14740
14741 performance_state->iNumberOfPerformanceLevels = 2;
14742
14743 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14744 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14745 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14746 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14747
14748 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14749 {
14750 log_info ("ERROR: Failed to set ADL performance state");
14751
14752 return (-1);
14753 }
14754
14755 local_free (performance_state);
14756 }
14757 }
14758
14759 hc_thread_mutex_unlock (mux_adl);
14760 }
14761 #endif // HAVE_HWMON && HAVE_ADL
14762 }
14763
14764 data.kernel_power_all = kernel_power_all;
14765
14766 if (data.quiet == 0) log_info ("");
14767
14768 /**
14769 * Inform user which algorithm is checked and at which workload setting
14770 */
14771
14772 if (benchmark == 1)
14773 {
14774 quiet = 0;
14775
14776 data.quiet = quiet;
14777
14778 char *hash_type = strhashtype (data.hash_mode); // not a bug
14779
14780 log_info ("Hashtype: %s", hash_type);
14781 log_info ("");
14782 }
14783
14784 /**
14785 * keep track of the progress
14786 */
14787
14788 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14789 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14790 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14791
14792 /**
14793 * open filehandles
14794 */
14795
14796 #if _WIN
14797 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14798 {
14799 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14800
14801 return (-1);
14802 }
14803
14804 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14805 {
14806 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14807
14808 return (-1);
14809 }
14810
14811 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14812 {
14813 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14814
14815 return (-1);
14816 }
14817 #endif
14818
14819 /**
14820 * dictionary pad
14821 */
14822
14823 segment_size *= (1024 * 1024);
14824
14825 data.segment_size = segment_size;
14826
14827 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14828
14829 wl_data->buf = (char *) mymalloc (segment_size);
14830 wl_data->avail = segment_size;
14831 wl_data->incr = segment_size;
14832 wl_data->cnt = 0;
14833 wl_data->pos = 0;
14834
14835 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14836
14837 data.wordlist_mode = wordlist_mode;
14838
14839 cs_t *css_buf = NULL;
14840 uint css_cnt = 0;
14841 uint dictcnt = 0;
14842 uint maskcnt = 1;
14843 char **masks = NULL;
14844 char **dictfiles = NULL;
14845
14846 uint mask_from_file = 0;
14847
14848 if (attack_mode == ATTACK_MODE_STRAIGHT)
14849 {
14850 if (wordlist_mode == WL_MODE_FILE)
14851 {
14852 int wls_left = myargc - (optind + 1);
14853
14854 for (int i = 0; i < wls_left; i++)
14855 {
14856 char *l0_filename = myargv[optind + 1 + i];
14857
14858 struct stat l0_stat;
14859
14860 if (stat (l0_filename, &l0_stat) == -1)
14861 {
14862 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14863
14864 return (-1);
14865 }
14866
14867 uint is_dir = S_ISDIR (l0_stat.st_mode);
14868
14869 if (is_dir == 0)
14870 {
14871 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14872
14873 dictcnt++;
14874
14875 dictfiles[dictcnt - 1] = l0_filename;
14876 }
14877 else
14878 {
14879 // do not allow --keyspace w/ a directory
14880
14881 if (keyspace == 1)
14882 {
14883 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14884
14885 return (-1);
14886 }
14887
14888 char **dictionary_files = NULL;
14889
14890 dictionary_files = scan_directory (l0_filename);
14891
14892 if (dictionary_files != NULL)
14893 {
14894 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14895
14896 for (int d = 0; dictionary_files[d] != NULL; d++)
14897 {
14898 char *l1_filename = dictionary_files[d];
14899
14900 struct stat l1_stat;
14901
14902 if (stat (l1_filename, &l1_stat) == -1)
14903 {
14904 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14905
14906 return (-1);
14907 }
14908
14909 if (S_ISREG (l1_stat.st_mode))
14910 {
14911 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14912
14913 dictcnt++;
14914
14915 dictfiles[dictcnt - 1] = strdup (l1_filename);
14916 }
14917 }
14918 }
14919
14920 local_free (dictionary_files);
14921 }
14922 }
14923
14924 if (dictcnt < 1)
14925 {
14926 log_error ("ERROR: No usable dictionary file found.");
14927
14928 return (-1);
14929 }
14930 }
14931 else if (wordlist_mode == WL_MODE_STDIN)
14932 {
14933 dictcnt = 1;
14934 }
14935 }
14936 else if (attack_mode == ATTACK_MODE_COMBI)
14937 {
14938 // display
14939
14940 char *dictfile1 = myargv[optind + 1 + 0];
14941 char *dictfile2 = myargv[optind + 1 + 1];
14942
14943 // find the bigger dictionary and use as base
14944
14945 FILE *fp1 = NULL;
14946 FILE *fp2 = NULL;
14947
14948 struct stat tmp_stat;
14949
14950 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14951 {
14952 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14953
14954 return (-1);
14955 }
14956
14957 if (stat (dictfile1, &tmp_stat) == -1)
14958 {
14959 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14960
14961 fclose (fp1);
14962
14963 return (-1);
14964 }
14965
14966 if (S_ISDIR (tmp_stat.st_mode))
14967 {
14968 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14969
14970 fclose (fp1);
14971
14972 return (-1);
14973 }
14974
14975 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14976 {
14977 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14978
14979 fclose (fp1);
14980
14981 return (-1);
14982 }
14983
14984 if (stat (dictfile2, &tmp_stat) == -1)
14985 {
14986 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14987
14988 fclose (fp1);
14989 fclose (fp2);
14990
14991 return (-1);
14992 }
14993
14994 if (S_ISDIR (tmp_stat.st_mode))
14995 {
14996 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14997
14998 fclose (fp1);
14999 fclose (fp2);
15000
15001 return (-1);
15002 }
15003
15004 data.combs_cnt = 1;
15005
15006 data.quiet = 1;
15007
15008 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15009
15010 data.quiet = quiet;
15011
15012 if (words1_cnt == 0)
15013 {
15014 log_error ("ERROR: %s: empty file", dictfile1);
15015
15016 fclose (fp1);
15017 fclose (fp2);
15018
15019 return (-1);
15020 }
15021
15022 data.combs_cnt = 1;
15023
15024 data.quiet = 1;
15025
15026 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15027
15028 data.quiet = quiet;
15029
15030 if (words2_cnt == 0)
15031 {
15032 log_error ("ERROR: %s: empty file", dictfile2);
15033
15034 fclose (fp1);
15035 fclose (fp2);
15036
15037 return (-1);
15038 }
15039
15040 fclose (fp1);
15041 fclose (fp2);
15042
15043 data.dictfile = dictfile1;
15044 data.dictfile2 = dictfile2;
15045
15046 if (words1_cnt >= words2_cnt)
15047 {
15048 data.combs_cnt = words2_cnt;
15049 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15050
15051 dictfiles = &data.dictfile;
15052
15053 dictcnt = 1;
15054 }
15055 else
15056 {
15057 data.combs_cnt = words1_cnt;
15058 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15059
15060 dictfiles = &data.dictfile2;
15061
15062 dictcnt = 1;
15063
15064 // we also have to switch wordlist related rules!
15065
15066 char *tmpc = data.rule_buf_l;
15067
15068 data.rule_buf_l = data.rule_buf_r;
15069 data.rule_buf_r = tmpc;
15070
15071 int tmpi = data.rule_len_l;
15072
15073 data.rule_len_l = data.rule_len_r;
15074 data.rule_len_r = tmpi;
15075 }
15076 }
15077 else if (attack_mode == ATTACK_MODE_BF)
15078 {
15079 char *mask = NULL;
15080
15081 maskcnt = 0;
15082
15083 if (benchmark == 0)
15084 {
15085 mask = myargv[optind + 1];
15086
15087 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15088
15089 if ((optind + 2) <= myargc)
15090 {
15091 struct stat file_stat;
15092
15093 if (stat (mask, &file_stat) == -1)
15094 {
15095 maskcnt = 1;
15096
15097 masks[maskcnt - 1] = mystrdup (mask);
15098 }
15099 else
15100 {
15101 int wls_left = myargc - (optind + 1);
15102
15103 uint masks_avail = INCR_MASKS;
15104
15105 for (int i = 0; i < wls_left; i++)
15106 {
15107 if (i != 0)
15108 {
15109 mask = myargv[optind + 1 + i];
15110
15111 if (stat (mask, &file_stat) == -1)
15112 {
15113 log_error ("ERROR: %s: %s", mask, strerror (errno));
15114
15115 return (-1);
15116 }
15117 }
15118
15119 uint is_file = S_ISREG (file_stat.st_mode);
15120
15121 if (is_file == 1)
15122 {
15123 FILE *mask_fp;
15124
15125 if ((mask_fp = fopen (mask, "r")) == NULL)
15126 {
15127 log_error ("ERROR: %s: %s", mask, strerror (errno));
15128
15129 return (-1);
15130 }
15131
15132 char line_buf[BUFSIZ] = { 0 };
15133
15134 while (!feof (mask_fp))
15135 {
15136 memset (line_buf, 0, BUFSIZ);
15137
15138 int line_len = fgetl (mask_fp, line_buf);
15139
15140 if (line_len == 0) continue;
15141
15142 if (line_buf[0] == '#') continue;
15143
15144 if (masks_avail == maskcnt)
15145 {
15146 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15147
15148 masks_avail += INCR_MASKS;
15149 }
15150
15151 masks[maskcnt] = mystrdup (line_buf);
15152
15153 maskcnt++;
15154 }
15155
15156 fclose (mask_fp);
15157 }
15158 else
15159 {
15160 log_error ("ERROR: %s: unsupported file-type", mask);
15161
15162 return (-1);
15163 }
15164 }
15165
15166 mask_from_file = 1;
15167 }
15168 }
15169 else
15170 {
15171 custom_charset_1 = (char *) "?l?d?u";
15172 custom_charset_2 = (char *) "?l?d";
15173 custom_charset_3 = (char *) "?l?d*!$@_";
15174
15175 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15176 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15177 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15178
15179 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15180
15181 wordlist_mode = WL_MODE_MASK;
15182
15183 data.wordlist_mode = wordlist_mode;
15184
15185 increment = 1;
15186
15187 maskcnt = 1;
15188 }
15189 }
15190 else
15191 {
15192 /**
15193 * generate full masks and charsets
15194 */
15195
15196 masks = (char **) mymalloc (sizeof (char *));
15197
15198 switch (hash_mode)
15199 {
15200 case 1731: pw_min = 5;
15201 pw_max = 5;
15202 mask = mystrdup ("?b?b?b?b?b");
15203 break;
15204 case 12500: pw_min = 5;
15205 pw_max = 5;
15206 mask = mystrdup ("?b?b?b?b?b");
15207 break;
15208 default: pw_min = 7;
15209 pw_max = 7;
15210 mask = mystrdup ("?b?b?b?b?b?b?b");
15211 break;
15212 }
15213
15214 maskcnt = 1;
15215
15216 masks[maskcnt - 1] = mystrdup (mask);
15217
15218 wordlist_mode = WL_MODE_MASK;
15219
15220 data.wordlist_mode = wordlist_mode;
15221
15222 increment = 1;
15223 }
15224
15225 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15226
15227 if (increment)
15228 {
15229 if (increment_min > pw_min) pw_min = increment_min;
15230
15231 if (increment_max < pw_max) pw_max = increment_max;
15232 }
15233 }
15234 else if (attack_mode == ATTACK_MODE_HYBRID1)
15235 {
15236 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15237
15238 // display
15239
15240 char *mask = myargv[myargc - 1];
15241
15242 maskcnt = 0;
15243
15244 masks = (char **) mymalloc (1 * sizeof (char *));
15245
15246 // mod
15247
15248 struct stat file_stat;
15249
15250 if (stat (mask, &file_stat) == -1)
15251 {
15252 maskcnt = 1;
15253
15254 masks[maskcnt - 1] = mystrdup (mask);
15255 }
15256 else
15257 {
15258 uint is_file = S_ISREG (file_stat.st_mode);
15259
15260 if (is_file == 1)
15261 {
15262 FILE *mask_fp;
15263
15264 if ((mask_fp = fopen (mask, "r")) == NULL)
15265 {
15266 log_error ("ERROR: %s: %s", mask, strerror (errno));
15267
15268 return (-1);
15269 }
15270
15271 char line_buf[BUFSIZ] = { 0 };
15272
15273 uint masks_avail = 1;
15274
15275 while (!feof (mask_fp))
15276 {
15277 memset (line_buf, 0, BUFSIZ);
15278
15279 int line_len = fgetl (mask_fp, line_buf);
15280
15281 if (line_len == 0) continue;
15282
15283 if (line_buf[0] == '#') continue;
15284
15285 if (masks_avail == maskcnt)
15286 {
15287 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15288
15289 masks_avail += INCR_MASKS;
15290 }
15291
15292 masks[maskcnt] = mystrdup (line_buf);
15293
15294 maskcnt++;
15295 }
15296
15297 fclose (mask_fp);
15298
15299 mask_from_file = 1;
15300 }
15301 else
15302 {
15303 maskcnt = 1;
15304
15305 masks[maskcnt - 1] = mystrdup (mask);
15306 }
15307 }
15308
15309 // base
15310
15311 int wls_left = myargc - (optind + 2);
15312
15313 for (int i = 0; i < wls_left; i++)
15314 {
15315 char *filename = myargv[optind + 1 + i];
15316
15317 struct stat file_stat;
15318
15319 if (stat (filename, &file_stat) == -1)
15320 {
15321 log_error ("ERROR: %s: %s", filename, strerror (errno));
15322
15323 return (-1);
15324 }
15325
15326 uint is_dir = S_ISDIR (file_stat.st_mode);
15327
15328 if (is_dir == 0)
15329 {
15330 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15331
15332 dictcnt++;
15333
15334 dictfiles[dictcnt - 1] = filename;
15335 }
15336 else
15337 {
15338 // do not allow --keyspace w/ a directory
15339
15340 if (keyspace == 1)
15341 {
15342 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15343
15344 return (-1);
15345 }
15346
15347 char **dictionary_files = NULL;
15348
15349 dictionary_files = scan_directory (filename);
15350
15351 if (dictionary_files != NULL)
15352 {
15353 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15354
15355 for (int d = 0; dictionary_files[d] != NULL; d++)
15356 {
15357 char *l1_filename = dictionary_files[d];
15358
15359 struct stat l1_stat;
15360
15361 if (stat (l1_filename, &l1_stat) == -1)
15362 {
15363 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15364
15365 return (-1);
15366 }
15367
15368 if (S_ISREG (l1_stat.st_mode))
15369 {
15370 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15371
15372 dictcnt++;
15373
15374 dictfiles[dictcnt - 1] = strdup (l1_filename);
15375 }
15376 }
15377 }
15378
15379 local_free (dictionary_files);
15380 }
15381 }
15382
15383 if (dictcnt < 1)
15384 {
15385 log_error ("ERROR: No usable dictionary file found.");
15386
15387 return (-1);
15388 }
15389
15390 if (increment)
15391 {
15392 maskcnt = 0;
15393
15394 uint mask_min = increment_min; // we can't reject smaller masks here
15395 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15396
15397 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15398 {
15399 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15400
15401 if (cur_mask == NULL) break;
15402
15403 masks[maskcnt] = cur_mask;
15404
15405 maskcnt++;
15406
15407 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15408 }
15409 }
15410 }
15411 else if (attack_mode == ATTACK_MODE_HYBRID2)
15412 {
15413 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15414
15415 // display
15416
15417 char *mask = myargv[optind + 1 + 0];
15418
15419 maskcnt = 0;
15420
15421 masks = (char **) mymalloc (1 * sizeof (char *));
15422
15423 // mod
15424
15425 struct stat file_stat;
15426
15427 if (stat (mask, &file_stat) == -1)
15428 {
15429 maskcnt = 1;
15430
15431 masks[maskcnt - 1] = mystrdup (mask);
15432 }
15433 else
15434 {
15435 uint is_file = S_ISREG (file_stat.st_mode);
15436
15437 if (is_file == 1)
15438 {
15439 FILE *mask_fp;
15440
15441 if ((mask_fp = fopen (mask, "r")) == NULL)
15442 {
15443 log_error ("ERROR: %s: %s", mask, strerror (errno));
15444
15445 return (-1);
15446 }
15447
15448 char line_buf[BUFSIZ] = { 0 };
15449
15450 uint masks_avail = 1;
15451
15452 while (!feof (mask_fp))
15453 {
15454 memset (line_buf, 0, BUFSIZ);
15455
15456 int line_len = fgetl (mask_fp, line_buf);
15457
15458 if (line_len == 0) continue;
15459
15460 if (line_buf[0] == '#') continue;
15461
15462 if (masks_avail == maskcnt)
15463 {
15464 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15465
15466 masks_avail += INCR_MASKS;
15467 }
15468
15469 masks[maskcnt] = mystrdup (line_buf);
15470
15471 maskcnt++;
15472 }
15473
15474 fclose (mask_fp);
15475
15476 mask_from_file = 1;
15477 }
15478 else
15479 {
15480 maskcnt = 1;
15481
15482 masks[maskcnt - 1] = mystrdup (mask);
15483 }
15484 }
15485
15486 // base
15487
15488 int wls_left = myargc - (optind + 2);
15489
15490 for (int i = 0; i < wls_left; i++)
15491 {
15492 char *filename = myargv[optind + 2 + i];
15493
15494 struct stat file_stat;
15495
15496 if (stat (filename, &file_stat) == -1)
15497 {
15498 log_error ("ERROR: %s: %s", filename, strerror (errno));
15499
15500 return (-1);
15501 }
15502
15503 uint is_dir = S_ISDIR (file_stat.st_mode);
15504
15505 if (is_dir == 0)
15506 {
15507 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15508
15509 dictcnt++;
15510
15511 dictfiles[dictcnt - 1] = filename;
15512 }
15513 else
15514 {
15515 // do not allow --keyspace w/ a directory
15516
15517 if (keyspace == 1)
15518 {
15519 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15520
15521 return (-1);
15522 }
15523
15524 char **dictionary_files = NULL;
15525
15526 dictionary_files = scan_directory (filename);
15527
15528 if (dictionary_files != NULL)
15529 {
15530 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15531
15532 for (int d = 0; dictionary_files[d] != NULL; d++)
15533 {
15534 char *l1_filename = dictionary_files[d];
15535
15536 struct stat l1_stat;
15537
15538 if (stat (l1_filename, &l1_stat) == -1)
15539 {
15540 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15541
15542 return (-1);
15543 }
15544
15545 if (S_ISREG (l1_stat.st_mode))
15546 {
15547 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15548
15549 dictcnt++;
15550
15551 dictfiles[dictcnt - 1] = strdup (l1_filename);
15552 }
15553 }
15554 }
15555
15556 local_free (dictionary_files);
15557 }
15558 }
15559
15560 if (dictcnt < 1)
15561 {
15562 log_error ("ERROR: No usable dictionary file found.");
15563
15564 return (-1);
15565 }
15566
15567 if (increment)
15568 {
15569 maskcnt = 0;
15570
15571 uint mask_min = increment_min; // we can't reject smaller masks here
15572 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15573
15574 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15575 {
15576 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15577
15578 if (cur_mask == NULL) break;
15579
15580 masks[maskcnt] = cur_mask;
15581
15582 maskcnt++;
15583
15584 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15585 }
15586 }
15587 }
15588
15589 data.pw_min = pw_min;
15590 data.pw_max = pw_max;
15591
15592 /**
15593 * weak hash check
15594 */
15595
15596 if (weak_hash_threshold >= salts_cnt)
15597 {
15598 hc_device_param_t *device_param = NULL;
15599
15600 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15601 {
15602 device_param = &data.devices_param[device_id];
15603
15604 if (device_param->skipped) continue;
15605
15606 break;
15607 }
15608
15609 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15610
15611 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15612 {
15613 weak_hash_check (device_param, salt_pos);
15614 }
15615 }
15616
15617 // Display hack, guarantee that there is at least one \r before real start
15618
15619 if (data.quiet == 0) log_info_nn ("");
15620
15621 /**
15622 * status and monitor threads
15623 */
15624
15625 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15626
15627 hc_thread_t i_thread = 0;
15628
15629 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15630 {
15631 hc_thread_create (i_thread, thread_keypress, &benchmark);
15632 }
15633
15634 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15635
15636 uint ni_threads_cnt = 0;
15637
15638 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15639
15640 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15641
15642 ni_threads_cnt++;
15643
15644 /**
15645 * Outfile remove
15646 */
15647
15648 if (keyspace == 0)
15649 {
15650 if (outfile_check_timer != 0)
15651 {
15652 if (data.outfile_check_directory != NULL)
15653 {
15654 if ((hash_mode != 5200) &&
15655 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15656 (hash_mode != 9000))
15657 {
15658 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15659
15660 ni_threads_cnt++;
15661 }
15662 else
15663 {
15664 outfile_check_timer = 0;
15665 }
15666 }
15667 else
15668 {
15669 outfile_check_timer = 0;
15670 }
15671 }
15672 }
15673
15674 /**
15675 * Inform the user if we got some hashes remove because of the pot file remove feature
15676 */
15677
15678 if (data.quiet == 0)
15679 {
15680 if (potfile_remove_cracks > 0)
15681 {
15682 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15683 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15684 }
15685 }
15686
15687 data.outfile_check_timer = outfile_check_timer;
15688
15689 /**
15690 * main loop
15691 */
15692
15693 char **induction_dictionaries = NULL;
15694
15695 int induction_dictionaries_cnt = 0;
15696
15697 hcstat_table_t *root_table_buf = NULL;
15698 hcstat_table_t *markov_table_buf = NULL;
15699
15700 uint initial_restore_done = 0;
15701
15702 data.maskcnt = maskcnt;
15703
15704 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15705 {
15706 if (data.devices_status == STATUS_CRACKED) break;
15707
15708 data.devices_status = STATUS_INIT;
15709
15710 if (maskpos > rd->maskpos)
15711 {
15712 rd->dictpos = 0;
15713 }
15714
15715 rd->maskpos = maskpos;
15716 data.maskpos = maskpos;
15717
15718 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15719 {
15720 char *mask = masks[maskpos];
15721
15722 if (mask_from_file == 1)
15723 {
15724 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15725
15726 char *str_ptr;
15727 uint str_pos;
15728
15729 uint mask_offset = 0;
15730
15731 uint separator_cnt;
15732
15733 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15734 {
15735 str_ptr = strstr (mask + mask_offset, ",");
15736
15737 if (str_ptr == NULL) break;
15738
15739 str_pos = str_ptr - mask;
15740
15741 // escaped separator, i.e. "\,"
15742
15743 if (str_pos > 0)
15744 {
15745 if (mask[str_pos - 1] == '\\')
15746 {
15747 separator_cnt --;
15748
15749 mask_offset = str_pos + 1;
15750
15751 continue;
15752 }
15753 }
15754
15755 // reset the offset
15756
15757 mask_offset = 0;
15758
15759 mask[str_pos] = '\0';
15760
15761 switch (separator_cnt)
15762 {
15763 case 0:
15764 mp_reset_usr (mp_usr, 0);
15765
15766 custom_charset_1 = mask;
15767 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15768 break;
15769
15770 case 1:
15771 mp_reset_usr (mp_usr, 1);
15772
15773 custom_charset_2 = mask;
15774 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15775 break;
15776
15777 case 2:
15778 mp_reset_usr (mp_usr, 2);
15779
15780 custom_charset_3 = mask;
15781 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15782 break;
15783
15784 case 3:
15785 mp_reset_usr (mp_usr, 3);
15786
15787 custom_charset_4 = mask;
15788 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15789 break;
15790 }
15791
15792 mask = mask + str_pos + 1;
15793 }
15794 }
15795
15796 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15797 {
15798 if (maskpos > 0)
15799 {
15800 local_free (css_buf);
15801 local_free (data.root_css_buf);
15802 local_free (data.markov_css_buf);
15803
15804 local_free (masks[maskpos - 1]);
15805 }
15806
15807 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15808
15809 data.mask = mask;
15810 data.css_cnt = css_cnt;
15811 data.css_buf = css_buf;
15812
15813 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15814
15815 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15816
15817 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15818 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15819
15820 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15821
15822 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15823
15824 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15825 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15826
15827 data.root_css_buf = root_css_buf;
15828 data.markov_css_buf = markov_css_buf;
15829
15830 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15831
15832 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15833
15834 local_free (root_table_buf);
15835 local_free (markov_table_buf);
15836
15837 // args
15838
15839 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15840 {
15841 hc_device_param_t *device_param = &data.devices_param[device_id];
15842
15843 if (device_param->skipped) continue;
15844
15845 device_param->kernel_params_mp[0] = &device_param->d_combs;
15846 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15847 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15848
15849 device_param->kernel_params_mp_buf64[3] = 0;
15850 device_param->kernel_params_mp_buf32[4] = css_cnt;
15851 device_param->kernel_params_mp_buf32[5] = 0;
15852 device_param->kernel_params_mp_buf32[6] = 0;
15853 device_param->kernel_params_mp_buf32[7] = 0;
15854
15855 if (attack_mode == ATTACK_MODE_HYBRID1)
15856 {
15857 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15858 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15859 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15860 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15861 }
15862 else if (attack_mode == ATTACK_MODE_HYBRID2)
15863 {
15864 device_param->kernel_params_mp_buf32[5] = 0;
15865 device_param->kernel_params_mp_buf32[6] = 0;
15866 device_param->kernel_params_mp_buf32[7] = 0;
15867 }
15868
15869 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15870 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15871 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15872
15873 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
15874 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
15875 }
15876 }
15877 else if (attack_mode == ATTACK_MODE_BF)
15878 {
15879 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15880
15881 if (increment)
15882 {
15883 for (uint i = 0; i < dictcnt; i++)
15884 {
15885 local_free (dictfiles[i]);
15886 }
15887
15888 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15889 {
15890 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15891
15892 if (l1_filename == NULL) break;
15893
15894 dictcnt++;
15895
15896 dictfiles[dictcnt - 1] = l1_filename;
15897 }
15898 }
15899 else
15900 {
15901 dictcnt++;
15902
15903 dictfiles[dictcnt - 1] = mask;
15904 }
15905
15906 if (dictcnt == 0)
15907 {
15908 log_error ("ERROR: Mask is too small");
15909
15910 return (-1);
15911 }
15912 }
15913 }
15914
15915 free (induction_dictionaries);
15916
15917 // induction_dictionaries_cnt = 0; // implied
15918
15919 if (attack_mode != ATTACK_MODE_BF)
15920 {
15921 if (keyspace == 0)
15922 {
15923 induction_dictionaries = scan_directory (induction_directory);
15924
15925 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15926 }
15927 }
15928
15929 if (induction_dictionaries_cnt)
15930 {
15931 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15932 }
15933
15934 /**
15935 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15936 */
15937 if (keyspace == 1)
15938 {
15939 if ((maskcnt > 1) || (dictcnt > 1))
15940 {
15941 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15942
15943 return (-1);
15944 }
15945 }
15946
15947 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15948 {
15949 char *subid = logfile_generate_subid ();
15950
15951 data.subid = subid;
15952
15953 logfile_sub_msg ("START");
15954
15955 data.devices_status = STATUS_INIT;
15956
15957 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15958 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15959 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15960
15961 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15962
15963 data.cpt_pos = 0;
15964
15965 data.cpt_start = time (NULL);
15966
15967 data.cpt_total = 0;
15968
15969 if (data.restore == 0)
15970 {
15971 rd->words_cur = skip;
15972
15973 skip = 0;
15974
15975 data.skip = 0;
15976 }
15977
15978 data.ms_paused = 0;
15979
15980 data.words_cur = rd->words_cur;
15981
15982 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15983 {
15984 hc_device_param_t *device_param = &data.devices_param[device_id];
15985
15986 if (device_param->skipped) continue;
15987
15988 device_param->speed_pos = 0;
15989
15990 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15991 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15992 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15993
15994 device_param->exec_pos = 0;
15995
15996 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15997
15998 device_param->kernel_power = device_param->kernel_power_user;
15999
16000 device_param->outerloop_pos = 0;
16001 device_param->outerloop_left = 0;
16002 device_param->innerloop_pos = 0;
16003 device_param->innerloop_left = 0;
16004
16005 // some more resets:
16006
16007 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
16008
16009 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16010
16011 device_param->pw_cnt = 0;
16012 device_param->pws_cnt = 0;
16013
16014 device_param->words_off = 0;
16015 device_param->words_done = 0;
16016 }
16017
16018 data.kernel_power_div = 0;
16019
16020 // figure out some workload
16021
16022 if (attack_mode == ATTACK_MODE_STRAIGHT)
16023 {
16024 if (data.wordlist_mode == WL_MODE_FILE)
16025 {
16026 char *dictfile = NULL;
16027
16028 if (induction_dictionaries_cnt)
16029 {
16030 dictfile = induction_dictionaries[0];
16031 }
16032 else
16033 {
16034 dictfile = dictfiles[dictpos];
16035 }
16036
16037 data.dictfile = dictfile;
16038
16039 logfile_sub_string (dictfile);
16040
16041 for (uint i = 0; i < rp_files_cnt; i++)
16042 {
16043 logfile_sub_var_string ("rulefile", rp_files[i]);
16044 }
16045
16046 FILE *fd2 = fopen (dictfile, "rb");
16047
16048 if (fd2 == NULL)
16049 {
16050 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16051
16052 return (-1);
16053 }
16054
16055 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16056
16057 fclose (fd2);
16058
16059 if (data.words_cnt == 0)
16060 {
16061 if (data.devices_status == STATUS_CRACKED) break;
16062 if (data.devices_status == STATUS_ABORTED) break;
16063
16064 dictpos++;
16065
16066 continue;
16067 }
16068 }
16069 }
16070 else if (attack_mode == ATTACK_MODE_COMBI)
16071 {
16072 char *dictfile = data.dictfile;
16073 char *dictfile2 = data.dictfile2;
16074
16075 logfile_sub_string (dictfile);
16076 logfile_sub_string (dictfile2);
16077
16078 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16079 {
16080 FILE *fd2 = fopen (dictfile, "rb");
16081
16082 if (fd2 == NULL)
16083 {
16084 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16085
16086 return (-1);
16087 }
16088
16089 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16090
16091 fclose (fd2);
16092 }
16093 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16094 {
16095 FILE *fd2 = fopen (dictfile2, "rb");
16096
16097 if (fd2 == NULL)
16098 {
16099 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16100
16101 return (-1);
16102 }
16103
16104 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16105
16106 fclose (fd2);
16107 }
16108
16109 if (data.words_cnt == 0)
16110 {
16111 if (data.devices_status == STATUS_CRACKED) break;
16112 if (data.devices_status == STATUS_ABORTED) break;
16113
16114 dictpos++;
16115
16116 continue;
16117 }
16118 }
16119 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16120 {
16121 char *dictfile = NULL;
16122
16123 if (induction_dictionaries_cnt)
16124 {
16125 dictfile = induction_dictionaries[0];
16126 }
16127 else
16128 {
16129 dictfile = dictfiles[dictpos];
16130 }
16131
16132 data.dictfile = dictfile;
16133
16134 char *mask = data.mask;
16135
16136 logfile_sub_string (dictfile);
16137 logfile_sub_string (mask);
16138
16139 FILE *fd2 = fopen (dictfile, "rb");
16140
16141 if (fd2 == NULL)
16142 {
16143 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16144
16145 return (-1);
16146 }
16147
16148 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16149
16150 fclose (fd2);
16151
16152 if (data.words_cnt == 0)
16153 {
16154 if (data.devices_status == STATUS_CRACKED) break;
16155 if (data.devices_status == STATUS_ABORTED) break;
16156
16157 dictpos++;
16158
16159 continue;
16160 }
16161 }
16162 else if (attack_mode == ATTACK_MODE_BF)
16163 {
16164 local_free (css_buf);
16165 local_free (data.root_css_buf);
16166 local_free (data.markov_css_buf);
16167
16168 char *mask = dictfiles[dictpos];
16169
16170 logfile_sub_string (mask);
16171
16172 // base
16173
16174 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16175
16176 if (opts_type & OPTS_TYPE_PT_UNICODE)
16177 {
16178 uint css_cnt_unicode = css_cnt * 2;
16179
16180 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16181
16182 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16183 {
16184 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16185
16186 css_buf_unicode[j + 1].cs_buf[0] = 0;
16187 css_buf_unicode[j + 1].cs_len = 1;
16188 }
16189
16190 free (css_buf);
16191
16192 css_buf = css_buf_unicode;
16193 css_cnt = css_cnt_unicode;
16194 }
16195
16196 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16197
16198 uint mask_min = pw_min;
16199 uint mask_max = pw_max;
16200
16201 if (opts_type & OPTS_TYPE_PT_UNICODE)
16202 {
16203 mask_min *= 2;
16204 mask_max *= 2;
16205 }
16206
16207 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16208 {
16209 if (css_cnt < mask_min)
16210 {
16211 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16212 }
16213
16214 if (css_cnt > mask_max)
16215 {
16216 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16217 }
16218
16219 // skip to next mask
16220
16221 dictpos++;
16222
16223 rd->dictpos = dictpos;
16224
16225 logfile_sub_msg ("STOP");
16226
16227 continue;
16228 }
16229
16230 uint save_css_cnt = css_cnt;
16231
16232 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16233 {
16234 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16235 {
16236 uint salt_len = (uint) data.salts_buf[0].salt_len;
16237 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16238
16239 uint css_cnt_salt = css_cnt + salt_len;
16240
16241 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16242
16243 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16244
16245 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16246 {
16247 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16248 css_buf_salt[j].cs_len = 1;
16249 }
16250
16251 free (css_buf);
16252
16253 css_buf = css_buf_salt;
16254 css_cnt = css_cnt_salt;
16255 }
16256 }
16257
16258 data.mask = mask;
16259 data.css_cnt = css_cnt;
16260 data.css_buf = css_buf;
16261
16262 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16263
16264 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16265
16266 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16267
16268 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16269 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16270
16271 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16272
16273 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16274
16275 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16276 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16277
16278 data.root_css_buf = root_css_buf;
16279 data.markov_css_buf = markov_css_buf;
16280
16281 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16282
16283 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16284
16285 local_free (root_table_buf);
16286 local_free (markov_table_buf);
16287
16288 // copy + args
16289
16290 uint css_cnt_l = css_cnt;
16291 uint css_cnt_r;
16292
16293 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16294 {
16295 if (save_css_cnt < 6)
16296 {
16297 css_cnt_r = 1;
16298 }
16299 else if (save_css_cnt == 6)
16300 {
16301 css_cnt_r = 2;
16302 }
16303 else
16304 {
16305 if (opts_type & OPTS_TYPE_PT_UNICODE)
16306 {
16307 if (save_css_cnt == 8 || save_css_cnt == 10)
16308 {
16309 css_cnt_r = 2;
16310 }
16311 else
16312 {
16313 css_cnt_r = 4;
16314 }
16315 }
16316 else
16317 {
16318 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16319 {
16320 css_cnt_r = 3;
16321 }
16322 else
16323 {
16324 css_cnt_r = 4;
16325 }
16326 }
16327 }
16328 }
16329 else
16330 {
16331 css_cnt_r = 1;
16332
16333 /* unfinished code?
16334 int sum = css_buf[css_cnt_r - 1].cs_len;
16335
16336 for (uint i = 1; i < 4 && i < css_cnt; i++)
16337 {
16338 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16339
16340 css_cnt_r++;
16341
16342 sum *= css_buf[css_cnt_r - 1].cs_len;
16343 }
16344 */
16345 }
16346
16347 css_cnt_l -= css_cnt_r;
16348
16349 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16350
16351 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16352 {
16353 hc_device_param_t *device_param = &data.devices_param[device_id];
16354
16355 if (device_param->skipped) continue;
16356
16357 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16358 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16359 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16360
16361 device_param->kernel_params_mp_l_buf64[3] = 0;
16362 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16363 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16364 device_param->kernel_params_mp_l_buf32[6] = 0;
16365 device_param->kernel_params_mp_l_buf32[7] = 0;
16366 device_param->kernel_params_mp_l_buf32[8] = 0;
16367
16368 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16369 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16370 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16371 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16372
16373 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16374 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16375 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16376
16377 device_param->kernel_params_mp_r_buf64[3] = 0;
16378 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16379 device_param->kernel_params_mp_r_buf32[5] = 0;
16380 device_param->kernel_params_mp_r_buf32[6] = 0;
16381 device_param->kernel_params_mp_r_buf32[7] = 0;
16382
16383 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_l[i]);
16384 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_l[i]);
16385 for (uint i = 4; i < 9; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_l[i]);
16386
16387 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_r[i]);
16388 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_r[i]);
16389 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_r[i]);
16390
16391 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
16392 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
16393 }
16394 }
16395
16396 u64 words_base = data.words_cnt;
16397
16398 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16399 {
16400 if (data.kernel_rules_cnt)
16401 {
16402 words_base /= data.kernel_rules_cnt;
16403 }
16404 }
16405 else if (data.attack_kern == ATTACK_KERN_COMBI)
16406 {
16407 if (data.combs_cnt)
16408 {
16409 words_base /= data.combs_cnt;
16410 }
16411 }
16412 else if (data.attack_kern == ATTACK_KERN_BF)
16413 {
16414 if (data.bfs_cnt)
16415 {
16416 words_base /= data.bfs_cnt;
16417 }
16418 }
16419
16420 data.words_base = words_base;
16421
16422 if (keyspace == 1)
16423 {
16424 log_info ("%llu", (unsigned long long int) words_base);
16425
16426 return (0);
16427 }
16428
16429 if (data.words_cur > data.words_base)
16430 {
16431 log_error ("ERROR: restore value greater keyspace");
16432
16433 return (-1);
16434 }
16435
16436 if (data.words_cur)
16437 {
16438 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16439 {
16440 for (uint i = 0; i < data.salts_cnt; i++)
16441 {
16442 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16443 }
16444 }
16445 else if (data.attack_kern == ATTACK_KERN_COMBI)
16446 {
16447 for (uint i = 0; i < data.salts_cnt; i++)
16448 {
16449 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16450 }
16451 }
16452 else if (data.attack_kern == ATTACK_KERN_BF)
16453 {
16454 for (uint i = 0; i < data.salts_cnt; i++)
16455 {
16456 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16457 }
16458 }
16459 }
16460
16461 /*
16462 * Inform user about possible slow speeds
16463 */
16464
16465 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16466 {
16467 if (data.words_base < kernel_power_all)
16468 {
16469 if (quiet == 0)
16470 {
16471 log_info ("");
16472 log_info ("ATTENTION!");
16473 log_info (" The wordlist or mask you are using is too small.");
16474 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16475 log_info (" The cracking speed will drop.");
16476 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16477 log_info ("");
16478 }
16479 }
16480 }
16481
16482 /*
16483 * Update loopback file
16484 */
16485
16486 if (loopback == 1)
16487 {
16488 time_t now;
16489
16490 time (&now);
16491
16492 uint random_num = get_random_num (0, 9999);
16493
16494 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16495
16496 data.loopback_file = loopback_file;
16497 }
16498
16499 /*
16500 * Update dictionary statistic
16501 */
16502
16503 if (keyspace == 0)
16504 {
16505 dictstat_fp = fopen (dictstat, "wb");
16506
16507 if (dictstat_fp)
16508 {
16509 lock_file (dictstat_fp);
16510
16511 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16512
16513 fclose (dictstat_fp);
16514 }
16515 }
16516
16517 data.devices_status = STATUS_RUNNING;
16518
16519 if (initial_restore_done == 0)
16520 {
16521 if (data.restore_disable == 0) cycle_restore ();
16522
16523 initial_restore_done = 1;
16524 }
16525
16526 hc_timer_set (&data.timer_running);
16527
16528 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16529 {
16530 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16531 {
16532 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16533 if (quiet == 0) fflush (stdout);
16534 }
16535 }
16536 else if (wordlist_mode == WL_MODE_STDIN)
16537 {
16538 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16539 if (data.quiet == 0) log_info ("");
16540 }
16541
16542 time_t runtime_start;
16543
16544 time (&runtime_start);
16545
16546 data.runtime_start = runtime_start;
16547
16548 /**
16549 * create cracker threads
16550 */
16551
16552 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16553
16554 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16555 {
16556 hc_device_param_t *device_param = &devices_param[device_id];
16557
16558 if (wordlist_mode == WL_MODE_STDIN)
16559 {
16560 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16561 }
16562 else
16563 {
16564 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16565 }
16566 }
16567
16568 // wait for crack threads to exit
16569
16570 hc_thread_wait (data.devices_cnt, c_threads);
16571
16572 local_free (c_threads);
16573
16574 data.restore = 0;
16575
16576 // finalize task
16577
16578 logfile_sub_var_uint ("status-after-work", data.devices_status);
16579
16580 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16581
16582 if (data.devices_status == STATUS_CRACKED) break;
16583 if (data.devices_status == STATUS_ABORTED) break;
16584
16585 if (data.devices_status == STATUS_BYPASS)
16586 {
16587 data.devices_status = STATUS_RUNNING;
16588 }
16589
16590 if (induction_dictionaries_cnt)
16591 {
16592 unlink (induction_dictionaries[0]);
16593 }
16594
16595 free (induction_dictionaries);
16596
16597 if (attack_mode != ATTACK_MODE_BF)
16598 {
16599 induction_dictionaries = scan_directory (induction_directory);
16600
16601 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16602 }
16603
16604 if (benchmark == 0)
16605 {
16606 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16607 {
16608 if (quiet == 0) clear_prompt ();
16609
16610 if (quiet == 0) log_info ("");
16611
16612 if (status == 1)
16613 {
16614 status_display ();
16615 }
16616 else
16617 {
16618 if (quiet == 0) status_display ();
16619 }
16620
16621 if (quiet == 0) log_info ("");
16622 }
16623 }
16624
16625 if (attack_mode == ATTACK_MODE_BF)
16626 {
16627 dictpos++;
16628
16629 rd->dictpos = dictpos;
16630 }
16631 else
16632 {
16633 if (induction_dictionaries_cnt)
16634 {
16635 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16636 }
16637 else
16638 {
16639 dictpos++;
16640
16641 rd->dictpos = dictpos;
16642 }
16643 }
16644
16645 time_t runtime_stop;
16646
16647 time (&runtime_stop);
16648
16649 data.runtime_stop = runtime_stop;
16650
16651 logfile_sub_uint (runtime_start);
16652 logfile_sub_uint (runtime_stop);
16653
16654 logfile_sub_msg ("STOP");
16655
16656 global_free (subid);
16657 }
16658
16659 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16660
16661 if (data.devices_status == STATUS_CRACKED) break;
16662 if (data.devices_status == STATUS_ABORTED) break;
16663 if (data.devices_status == STATUS_QUIT) break;
16664
16665 if (data.devices_status == STATUS_BYPASS)
16666 {
16667 data.devices_status = STATUS_RUNNING;
16668 }
16669 }
16670
16671 // 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
16672
16673 if (attack_mode == ATTACK_MODE_STRAIGHT)
16674 {
16675 if (data.wordlist_mode == WL_MODE_FILE)
16676 {
16677 if (data.dictfile == NULL)
16678 {
16679 if (dictfiles != NULL)
16680 {
16681 data.dictfile = dictfiles[0];
16682
16683 hc_timer_set (&data.timer_running);
16684 }
16685 }
16686 }
16687 }
16688 // NOTE: combi is okay because it is already set beforehand
16689 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16690 {
16691 if (data.dictfile == NULL)
16692 {
16693 if (dictfiles != NULL)
16694 {
16695 hc_timer_set (&data.timer_running);
16696
16697 data.dictfile = dictfiles[0];
16698 }
16699 }
16700 }
16701 else if (attack_mode == ATTACK_MODE_BF)
16702 {
16703 if (data.mask == NULL)
16704 {
16705 hc_timer_set (&data.timer_running);
16706
16707 data.mask = masks[0];
16708 }
16709 }
16710
16711 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16712 {
16713 data.devices_status = STATUS_EXHAUSTED;
16714 }
16715
16716 // if cracked / aborted remove last induction dictionary
16717
16718 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16719 {
16720 struct stat induct_stat;
16721
16722 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16723 {
16724 unlink (induction_dictionaries[file_pos]);
16725 }
16726 }
16727
16728 // wait for non-interactive threads
16729
16730 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16731 {
16732 hc_thread_wait (1, &ni_threads[thread_idx]);
16733 }
16734
16735 local_free (ni_threads);
16736
16737 // wait for interactive threads
16738
16739 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16740 {
16741 hc_thread_wait (1, &i_thread);
16742 }
16743
16744 // we dont need restore file anymore
16745 if (data.restore_disable == 0)
16746 {
16747 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16748 {
16749 unlink (eff_restore_file);
16750 unlink (new_restore_file);
16751 }
16752 else
16753 {
16754 cycle_restore ();
16755 }
16756 }
16757
16758 // finally save left hashes
16759
16760 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16761 {
16762 save_hash ();
16763 }
16764
16765 /**
16766 * Clean up
16767 */
16768
16769 if (benchmark == 1)
16770 {
16771 status_benchmark ();
16772
16773 log_info ("");
16774 }
16775 else
16776 {
16777 if (quiet == 0) clear_prompt ();
16778
16779 if (quiet == 0) log_info ("");
16780
16781 if (status == 1)
16782 {
16783 status_display ();
16784 }
16785 else
16786 {
16787 if (quiet == 0) status_display ();
16788 }
16789
16790 if (quiet == 0) log_info ("");
16791 }
16792
16793 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16794 {
16795 hc_device_param_t *device_param = &data.devices_param[device_id];
16796
16797 if (device_param->skipped) continue;
16798
16799 local_free (device_param->result);
16800
16801 local_free (device_param->pw_caches);
16802
16803 local_free (device_param->combs_buf);
16804
16805 local_free (device_param->hooks_buf);
16806
16807 local_free (device_param->device_name);
16808
16809 local_free (device_param->device_name_chksum);
16810
16811 local_free (device_param->device_version);
16812
16813 local_free (device_param->driver_version);
16814
16815 if (device_param->pws_buf) myfree (device_param->pws_buf);
16816 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16817 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16818 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16819 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16820 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16821 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16822 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16823 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16824 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16825 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16826 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16827 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16828 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16829 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16830 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16831 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16832 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16833 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16834 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16835 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16836 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16837 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16838 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16839 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16840 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16841 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16842 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16843 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16844
16845 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16846 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16847 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16848 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16849 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16850 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16851 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16852 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16853 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16854 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16855 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16856
16857 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16858 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16859 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16860
16861 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16862 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16863 }
16864
16865 // reset default fan speed
16866
16867 #ifdef HAVE_HWMON
16868 if (gpu_temp_disable == 0)
16869 {
16870 #ifdef HAVE_ADL
16871 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16872 {
16873 hc_thread_mutex_lock (mux_adl);
16874
16875 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16876 {
16877 hc_device_param_t *device_param = &data.devices_param[device_id];
16878
16879 if (device_param->skipped) continue;
16880
16881 if (data.hm_device[device_id].fan_supported == 1)
16882 {
16883 int fanspeed = temp_retain_fanspeed_value[device_id];
16884
16885 if (fanspeed == -1) continue;
16886
16887 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16888
16889 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16890 }
16891 }
16892
16893 hc_thread_mutex_unlock (mux_adl);
16894 }
16895 #endif // HAVE_ADL
16896 }
16897
16898 #ifdef HAVE_ADL
16899 // reset power tuning
16900
16901 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16902 {
16903 hc_thread_mutex_lock (mux_adl);
16904
16905 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16906 {
16907 hc_device_param_t *device_param = &data.devices_param[device_id];
16908
16909 if (device_param->skipped) continue;
16910
16911 if (data.hm_device[device_id].od_version == 6)
16912 {
16913 // check powertune capabilities first, if not available then skip device
16914
16915 int powertune_supported = 0;
16916
16917 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16918 {
16919 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16920
16921 return (-1);
16922 }
16923
16924 if (powertune_supported != 0)
16925 {
16926 // powercontrol settings
16927
16928 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, od_power_control_status[device_id])) != ADL_OK)
16929 {
16930 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16931
16932 return (-1);
16933 }
16934
16935 // clocks
16936
16937 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16938
16939 performance_state->iNumberOfPerformanceLevels = 2;
16940
16941 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16942 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16943 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16944 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16945
16946 if ((hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16947 {
16948 log_info ("ERROR: Failed to restore ADL performance state");
16949
16950 return (-1);
16951 }
16952
16953 local_free (performance_state);
16954 }
16955 }
16956 }
16957
16958 hc_thread_mutex_unlock (mux_adl);
16959 }
16960 #endif // HAVE_ADL
16961
16962 if (gpu_temp_disable == 0)
16963 {
16964 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16965 if (data.hm_nv)
16966 {
16967 #if defined(LINUX) && defined(HAVE_NVML)
16968
16969 hm_NVML_nvmlShutdown (data.hm_nv);
16970
16971 nvml_close (data.hm_nv);
16972
16973 #elif defined(WIN) && (HAVE_NVAPI)
16974
16975 hm_NvAPI_Unload (data.hm_nv);
16976
16977 nvapi_close (data.hm_nv);
16978
16979 #endif
16980
16981 data.hm_nv = NULL;
16982 }
16983 #endif
16984
16985 #ifdef HAVE_ADL
16986 if (data.hm_amd)
16987 {
16988 hm_ADL_Main_Control_Destroy (data.hm_amd);
16989
16990 adl_close (data.hm_amd);
16991 data.hm_amd = NULL;
16992 }
16993 #endif
16994 }
16995 #endif // HAVE_HWMON
16996
16997 // free memory
16998
16999 local_free (masks);
17000
17001 local_free (dictstat_base);
17002
17003 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17004 {
17005 pot_t *pot_ptr = &pot[pot_pos];
17006
17007 hash_t *hash = &pot_ptr->hash;
17008
17009 local_free (hash->digest);
17010
17011 if (isSalted)
17012 {
17013 local_free (hash->salt);
17014 }
17015 }
17016
17017 local_free (pot);
17018
17019 local_free (all_kernel_rules_cnt);
17020 local_free (all_kernel_rules_buf);
17021
17022 local_free (wl_data->buf);
17023 local_free (wl_data);
17024
17025 local_free (bitmap_s1_a);
17026 local_free (bitmap_s1_b);
17027 local_free (bitmap_s1_c);
17028 local_free (bitmap_s1_d);
17029 local_free (bitmap_s2_a);
17030 local_free (bitmap_s2_b);
17031 local_free (bitmap_s2_c);
17032 local_free (bitmap_s2_d);
17033
17034 #ifdef HAVE_HWMON
17035 local_free (temp_retain_fanspeed_value);
17036 #ifdef HAVE_ADL
17037 local_free (od_clock_mem_status);
17038 local_free (od_power_control_status);
17039 #endif // ADL
17040 #endif
17041
17042 global_free (devices_param);
17043
17044 global_free (kernel_rules_buf);
17045
17046 global_free (root_css_buf);
17047 global_free (markov_css_buf);
17048
17049 global_free (digests_buf);
17050 global_free (digests_shown);
17051 global_free (digests_shown_tmp);
17052
17053 global_free (salts_buf);
17054 global_free (salts_shown);
17055
17056 global_free (esalts_buf);
17057
17058 global_free (words_progress_done);
17059 global_free (words_progress_rejected);
17060 global_free (words_progress_restored);
17061
17062 if (pot_fp) fclose (pot_fp);
17063
17064 if (data.devices_status == STATUS_QUIT) break;
17065 }
17066
17067 // destroy others mutex
17068
17069 hc_thread_mutex_delete (mux_dispatcher);
17070 hc_thread_mutex_delete (mux_counter);
17071 hc_thread_mutex_delete (mux_display);
17072 hc_thread_mutex_delete (mux_adl);
17073
17074 // free memory
17075
17076 local_free (eff_restore_file);
17077 local_free (new_restore_file);
17078
17079 local_free (rd);
17080
17081 // tuning db
17082
17083 tuning_db_destroy (tuning_db);
17084
17085 // loopback
17086
17087 local_free (loopback_file);
17088
17089 if (loopback == 1) unlink (loopback_file);
17090
17091 // induction directory
17092
17093 if (induction_dir == NULL)
17094 {
17095 if (attack_mode != ATTACK_MODE_BF)
17096 {
17097 if (rmdir (induction_directory) == -1)
17098 {
17099 if (errno == ENOENT)
17100 {
17101 // good, we can ignore
17102 }
17103 else if (errno == ENOTEMPTY)
17104 {
17105 // good, we can ignore
17106 }
17107 else
17108 {
17109 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17110
17111 return (-1);
17112 }
17113 }
17114
17115 local_free (induction_directory);
17116 }
17117 }
17118
17119 // outfile-check directory
17120
17121 if (outfile_check_dir == NULL)
17122 {
17123 if (rmdir (outfile_check_directory) == -1)
17124 {
17125 if (errno == ENOENT)
17126 {
17127 // good, we can ignore
17128 }
17129 else if (errno == ENOTEMPTY)
17130 {
17131 // good, we can ignore
17132 }
17133 else
17134 {
17135 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17136
17137 return (-1);
17138 }
17139 }
17140
17141 local_free (outfile_check_directory);
17142 }
17143
17144 time_t proc_stop;
17145
17146 time (&proc_stop);
17147
17148 logfile_top_uint (proc_start);
17149 logfile_top_uint (proc_stop);
17150
17151 logfile_top_msg ("STOP");
17152
17153 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17154 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17155
17156 if (data.ocl) ocl_close (data.ocl);
17157
17158 if (data.devices_status == STATUS_ABORTED) return 2;
17159 if (data.devices_status == STATUS_QUIT) return 2;
17160 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17161 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17162 if (data.devices_status == STATUS_CRACKED) return 0;
17163
17164 return -1;
17165 }
Hashcat additions to support pwdhash