projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
New format -m 13200 AxCrypt
[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 132
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 13200,
264 6211,
265 6221,
266 6231,
267 6241,
268 8800,
269 12900,
270 12200,
271 9700,
272 9710,
273 9800,
274 9810,
275 9400,
276 9500,
277 9600,
278 10400,
279 10410,
280 10500,
281 10600,
282 10700,
283 9000,
284 5200,
285 6800,
286 6600,
287 8200,
288 11300,
289 12700
290 };
291
292 /**
293 * types
294 */
295
296 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
297
298 /**
299 * globals
300 */
301
302 static unsigned int full01 = 0x01010101;
303 static unsigned int full80 = 0x80808080;
304
305 int SUPPRESS_OUTPUT = 0;
306
307 hc_thread_mutex_t mux_adl;
308 hc_thread_mutex_t mux_counter;
309 hc_thread_mutex_t mux_dispatcher;
310 hc_thread_mutex_t mux_display;
311
312 hc_global_data_t data;
313
314 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
315
316 const char *USAGE_MINI[] =
317 {
318 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
319 "",
320 "Try --help for more help.",
321 NULL
322 };
323
324 const char *USAGE_BIG[] =
325 {
326 "%s, advanced password recovery",
327 "",
328 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
329 "",
330 "=======",
331 "Options",
332 "=======",
333 "",
334 "* General:",
335 "",
336 " -m, --hash-type=NUM Hash-type, see references below",
337 " -a, --attack-mode=NUM Attack-mode, see references below",
338 " -V, --version Print version",
339 " -h, --help Print help",
340 " --quiet Suppress output",
341 "",
342 "* Misc:",
343 "",
344 " --hex-charset Assume charset is given in hex",
345 " --hex-salt Assume salt is given in hex",
346 " --hex-wordlist Assume words in wordlist is given in hex",
347 " --force Ignore warnings",
348 " --status Enable automatic update of the status-screen",
349 " --status-timer=NUM Seconds between status-screen update",
350 " --status-automat Display the status view in a machine readable format",
351 " --loopback Add new plains to induct directory",
352 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
353 "",
354 "* Markov:",
355 "",
356 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
357 " --markov-disable Disables markov-chains, emulates classic brute-force",
358 " --markov-classic Enables classic markov-chains, no per-position enhancement",
359 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
360 "",
361 "* Session:",
362 "",
363 " --runtime=NUM Abort session after NUM seconds of runtime",
364 " --session=STR Define specific session name",
365 " --restore Restore session from --session",
366 " --restore-disable Do not write restore file",
367 "",
368 "* Files:",
369 "",
370 " -o, --outfile=FILE Define outfile for recovered hash",
371 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
372 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
373 " --outfile-check-timer=NUM Seconds between outfile checks",
374 " -p, --separator=CHAR Separator char for hashlists and outfile",
375 " --show Show cracked passwords only",
376 " --left Show un-cracked passwords only",
377 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
378 " --remove Enable remove of hash once it is cracked",
379 " --remove-timer=NUM Update input hash file each NUM seconds",
380 " --potfile-disable Do not write potfile",
381 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
382 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
383 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
384 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
385 " --logfile-disable Disable the logfile",
386 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
387 "",
388 "* Resources:",
389 "",
390 " -b, --benchmark Run benchmark",
391 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
392 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
393 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
394 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
395 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
396 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
397 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
398 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
399 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
400 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
401 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
402 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
403 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
404 #ifdef HAVE_HWMON
405 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
406 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
407 #ifdef HAVE_ADL
408 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
409 #endif
410 #endif
411 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
412 "",
413 "* Distributed:",
414 "",
415 " -s, --skip=NUM Skip number of words",
416 " -l, --limit=NUM Limit number of words",
417 " --keyspace Show keyspace base:mod values and quit",
418 "",
419 "* Rules:",
420 "",
421 " -j, --rule-left=RULE Single rule applied to each word from left dict",
422 " -k, --rule-right=RULE Single rule applied to each word from right dict",
423 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
424 " -g, --generate-rules=NUM Generate NUM random rules",
425 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
426 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
427 " --generate-rules-seed=NUM Force RNG seed to NUM",
428 "",
429 "* Custom charsets:",
430 "",
431 " -1, --custom-charset1=CS User-defined charsets",
432 " -2, --custom-charset2=CS Example:",
433 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
434 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
435 "",
436 "* Increment:",
437 "",
438 " -i, --increment Enable increment mode",
439 " --increment-min=NUM Start incrementing at NUM",
440 " --increment-max=NUM Stop incrementing at NUM",
441 "",
442 "==========",
443 "References",
444 "==========",
445 "",
446 "* Workload Profile:",
447 "",
448 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
449 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
450 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
451 "",
452 "* OpenCL device-types:",
453 "",
454 " 1 = CPU devices",
455 " 2 = GPU devices",
456 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
457 "",
458 "* Outfile Formats:",
459 "",
460 " 1 = hash[:salt]",
461 " 2 = plain",
462 " 3 = hash[:salt]:plain",
463 " 4 = hex_plain",
464 " 5 = hash[:salt]:hex_plain",
465 " 6 = plain:hex_plain",
466 " 7 = hash[:salt]:plain:hex_plain",
467 " 8 = crackpos",
468 " 9 = hash[:salt]:crackpos",
469 " 10 = plain:crackpos",
470 " 11 = hash[:salt]:plain:crackpos",
471 " 12 = hex_plain:crackpos",
472 " 13 = hash[:salt]:hex_plain:crackpos",
473 " 14 = plain:hex_plain:crackpos",
474 " 15 = hash[:salt]:plain:hex_plain:crackpos",
475 "",
476 "* Debug mode output formats (for hybrid mode only, by using rules):",
477 "",
478 " 1 = save finding rule",
479 " 2 = save original word",
480 " 3 = save original word and finding rule",
481 " 4 = save original word, finding rule and modified plain",
482 "",
483 "* Built-in charsets:",
484 "",
485 " ?l = abcdefghijklmnopqrstuvwxyz",
486 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
487 " ?d = 0123456789",
488 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
489 " ?a = ?l?u?d?s",
490 " ?b = 0x00 - 0xff",
491 "",
492 "* Attack modes:",
493 "",
494 " 0 = Straight",
495 " 1 = Combination",
496 " 3 = Brute-force",
497 " 6 = Hybrid dict + mask",
498 " 7 = Hybrid mask + dict",
499 "",
500 "* Hash types:",
501 "",
502 "[[ Roll-your-own: Raw Hashes ]]",
503 "",
504 " 900 = MD4",
505 " 0 = MD5",
506 " 5100 = Half MD5",
507 " 100 = SHA1",
508 " 10800 = SHA-384",
509 " 1400 = SHA-256",
510 " 1700 = SHA-512",
511 " 5000 = SHA-3(Keccak)",
512 " 10100 = SipHash",
513 " 6000 = RipeMD160",
514 " 6100 = Whirlpool",
515 " 6900 = GOST R 34.11-94",
516 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
517 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
518 "",
519 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
520 "",
521 " 10 = md5($pass.$salt)",
522 " 20 = md5($salt.$pass)",
523 " 30 = md5(unicode($pass).$salt)",
524 " 40 = md5($salt.unicode($pass))",
525 " 3800 = md5($salt.$pass.$salt)",
526 " 3710 = md5($salt.md5($pass))",
527 " 2600 = md5(md5($pass)",
528 " 4300 = md5(strtoupper(md5($pass)))",
529 " 4400 = md5(sha1($pass))",
530 " 110 = sha1($pass.$salt)",
531 " 120 = sha1($salt.$pass)",
532 " 130 = sha1(unicode($pass).$salt)",
533 " 140 = sha1($salt.unicode($pass))",
534 " 4500 = sha1(sha1($pass)",
535 " 4700 = sha1(md5($pass))",
536 " 4900 = sha1($salt.$pass.$salt)",
537 " 1410 = sha256($pass.$salt)",
538 " 1420 = sha256($salt.$pass)",
539 " 1430 = sha256(unicode($pass).$salt)",
540 " 1440 = sha256($salt.unicode($pass))",
541 " 1710 = sha512($pass.$salt)",
542 " 1720 = sha512($salt.$pass)",
543 " 1730 = sha512(unicode($pass).$salt)",
544 " 1740 = sha512($salt.unicode($pass))",
545 "",
546 "[[ Roll-your-own: Authenticated Hashes ]]",
547 "",
548 " 50 = HMAC-MD5 (key = $pass)",
549 " 60 = HMAC-MD5 (key = $salt)",
550 " 150 = HMAC-SHA1 (key = $pass)",
551 " 160 = HMAC-SHA1 (key = $salt)",
552 " 1450 = HMAC-SHA256 (key = $pass)",
553 " 1460 = HMAC-SHA256 (key = $salt)",
554 " 1750 = HMAC-SHA512 (key = $pass)",
555 " 1760 = HMAC-SHA512 (key = $salt)",
556 "",
557 "[[ Generic KDF ]]",
558 "",
559 " 400 = phpass",
560 " 8900 = scrypt",
561 " 11900 = PBKDF2-HMAC-MD5",
562 " 12000 = PBKDF2-HMAC-SHA1",
563 " 10900 = PBKDF2-HMAC-SHA256",
564 " 12100 = PBKDF2-HMAC-SHA512",
565 "",
566 "[[ Network protocols, Challenge-Response ]]",
567 "",
568 " 23 = Skype",
569 " 2500 = WPA/WPA2",
570 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
571 " 5300 = IKE-PSK MD5",
572 " 5400 = IKE-PSK SHA1",
573 " 5500 = NetNTLMv1",
574 " 5500 = NetNTLMv1 + ESS",
575 " 5600 = NetNTLMv2",
576 " 7300 = IPMI2 RAKP HMAC-SHA1",
577 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
578 " 8300 = DNSSEC (NSEC3)",
579 " 10200 = Cram MD5",
580 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
581 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
582 " 11400 = SIP digest authentication (MD5)",
583 " 13100 = Kerberos 5 TGS-REP etype 23",
584 "",
585 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
586 "",
587 " 121 = SMF (Simple Machines Forum)",
588 " 400 = phpBB3",
589 " 2611 = vBulletin < v3.8.5",
590 " 2711 = vBulletin > v3.8.5",
591 " 2811 = MyBB",
592 " 2811 = IPB (Invison Power Board)",
593 " 8400 = WBB3 (Woltlab Burning Board)",
594 " 11 = Joomla < 2.5.18",
595 " 400 = Joomla > 2.5.18",
596 " 400 = Wordpress",
597 " 2612 = PHPS",
598 " 7900 = Drupal7",
599 " 21 = osCommerce",
600 " 21 = xt:Commerce",
601 " 11000 = PrestaShop",
602 " 124 = Django (SHA-1)",
603 " 10000 = Django (PBKDF2-SHA256)",
604 " 3711 = Mediawiki B type",
605 " 7600 = Redmine",
606 "",
607 "[[ Database Server ]]",
608 "",
609 " 12 = PostgreSQL",
610 " 131 = MSSQL(2000)",
611 " 132 = MSSQL(2005)",
612 " 1731 = MSSQL(2012)",
613 " 1731 = MSSQL(2014)",
614 " 200 = MySQL323",
615 " 300 = MySQL4.1/MySQL5",
616 " 3100 = Oracle H: Type (Oracle 7+)",
617 " 112 = Oracle S: Type (Oracle 11+)",
618 " 12300 = Oracle T: Type (Oracle 12+)",
619 " 8000 = Sybase ASE",
620 "",
621 "[[ HTTP, SMTP, LDAP Server ]]",
622 "",
623 " 141 = EPiServer 6.x < v4",
624 " 1441 = EPiServer 6.x > v4",
625 " 1600 = Apache $apr1$",
626 " 12600 = ColdFusion 10+",
627 " 1421 = hMailServer",
628 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
629 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
630 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
631 "",
632 "[[ Checksums ]]",
633 "",
634 " 11500 = CRC32",
635 "",
636 "[[ Operating-Systems ]]",
637 "",
638 " 3000 = LM",
639 " 1000 = NTLM",
640 " 1100 = Domain Cached Credentials (DCC), MS Cache",
641 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
642 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
643 " 1500 = descrypt, DES(Unix), Traditional DES",
644 " 12400 = BSDiCrypt, Extended DES",
645 " 500 = md5crypt $1$, MD5(Unix)",
646 " 3200 = bcrypt $2*$, Blowfish(Unix)",
647 " 7400 = sha256crypt $5$, SHA256(Unix)",
648 " 1800 = sha512crypt $6$, SHA512(Unix)",
649 " 122 = OSX v10.4",
650 " 122 = OSX v10.5",
651 " 122 = OSX v10.6",
652 " 1722 = OSX v10.7",
653 " 7100 = OSX v10.8",
654 " 7100 = OSX v10.9",
655 " 7100 = OSX v10.10",
656 " 6300 = AIX {smd5}",
657 " 6700 = AIX {ssha1}",
658 " 6400 = AIX {ssha256}",
659 " 6500 = AIX {ssha512}",
660 " 2400 = Cisco-PIX",
661 " 2410 = Cisco-ASA",
662 " 500 = Cisco-IOS $1$",
663 " 5700 = Cisco-IOS $4$",
664 " 9200 = Cisco-IOS $8$",
665 " 9300 = Cisco-IOS $9$",
666 " 22 = Juniper Netscreen/SSG (ScreenOS)",
667 " 501 = Juniper IVE",
668 " 5800 = Android PIN",
669 " 8100 = Citrix Netscaler",
670 " 8500 = RACF",
671 " 7200 = GRUB 2",
672 " 9900 = Radmin2",
673 "",
674 "[[ Enterprise Application Software (EAS) ]]",
675 "",
676 " 7700 = SAP CODVN B (BCODE)",
677 " 7800 = SAP CODVN F/G (PASSCODE)",
678 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
679 " 8600 = Lotus Notes/Domino 5",
680 " 8700 = Lotus Notes/Domino 6",
681 " 9100 = Lotus Notes/Domino 8",
682 " 133 = PeopleSoft",
683 "",
684 "[[ Archives ]]",
685 "",
686 " 11600 = 7-Zip",
687 " 12500 = RAR3-hp",
688 " 13000 = RAR5",
689 " 13200 = AxCrypt",
690 "",
691 "[[ Full-Disk encryptions (FDE) ]]",
692 "",
693 " 62XY = TrueCrypt 5.0+",
694 " X = 1 = PBKDF2-HMAC-RipeMD160",
695 " X = 2 = PBKDF2-HMAC-SHA512",
696 " X = 3 = PBKDF2-HMAC-Whirlpool",
697 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
698 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
699 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
700 " Y = 3 = XTS 1536 bit (Ciphers: All)",
701 " 8800 = Android FDE < v4.3",
702 " 12900 = Android FDE (Samsung DEK)",
703 " 12200 = eCryptfs",
704 "",
705 "[[ Documents ]]",
706 "",
707 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
708 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
709 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
710 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
711 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
712 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
713 " 9400 = MS Office 2007",
714 " 9500 = MS Office 2010",
715 " 9600 = MS Office 2013",
716 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
717 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
718 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
719 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
720 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
721 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
722 "",
723 "[[ Password Managers ]]",
724 "",
725 " 9000 = Password Safe v2",
726 " 5200 = Password Safe v3",
727 " 6800 = Lastpass",
728 " 6600 = 1Password, agilekeychain",
729 " 8200 = 1Password, cloudkeychain",
730 " 11300 = Bitcoin/Litecoin wallet.dat",
731 " 12700 = Blockchain, My Wallet",
732 "",
733 NULL
734 };
735
736 /**
737 * oclHashcat specific functions
738 */
739
740 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
741 {
742 int exec_pos = (int) device_param->exec_pos - last_num_entries;
743
744 if (exec_pos < 0) exec_pos += EXEC_CACHE;
745
746 double exec_ms_sum = 0;
747
748 int exec_ms_cnt = 0;
749
750 for (int i = 0; i < last_num_entries; i++)
751 {
752 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
753
754 if (exec_ms)
755 {
756 exec_ms_sum += exec_ms;
757
758 exec_ms_cnt++;
759 }
760 }
761
762 if (exec_ms_cnt == 0) return 0;
763
764 return exec_ms_sum / exec_ms_cnt;
765 }
766
767 void status_display_automat ()
768 {
769 FILE *out = stdout;
770
771 fprintf (out, "STATUS\t%u\t", data.devices_status);
772
773 /**
774 * speed new
775 */
776
777 fprintf (out, "SPEED\t");
778
779 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
780 {
781 hc_device_param_t *device_param = &data.devices_param[device_id];
782
783 if (device_param->skipped) continue;
784
785 u64 speed_cnt = 0;
786 float speed_ms = 0;
787
788 for (int i = 0; i < SPEED_CACHE; i++)
789 {
790 float rec_ms;
791
792 hc_timer_get (device_param->speed_rec[i], rec_ms);
793
794 if (rec_ms > SPEED_MAXAGE) continue;
795
796 speed_cnt += device_param->speed_cnt[i];
797 speed_ms += device_param->speed_ms[i];
798 }
799
800 speed_cnt /= SPEED_CACHE;
801 speed_ms /= SPEED_CACHE;
802
803 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
804 }
805
806 /**
807 * exec time
808 */
809
810 fprintf (out, "EXEC_RUNTIME\t");
811
812 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
813 {
814 hc_device_param_t *device_param = &data.devices_param[device_id];
815
816 if (device_param->skipped) continue;
817
818 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
819
820 fprintf (out, "%f\t", exec_ms_avg);
821 }
822
823 /**
824 * words_cur
825 */
826
827 u64 words_cur = get_lowest_words_done ();
828
829 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
830
831 /**
832 * counter
833 */
834
835 uint salts_left = data.salts_cnt - data.salts_done;
836
837 if (salts_left == 0) salts_left = 1;
838
839 u64 progress_total = data.words_cnt * salts_left;
840
841 u64 all_done = 0;
842 u64 all_rejected = 0;
843 u64 all_restored = 0;
844
845 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
846 {
847 if (salts_left > 1)
848 {
849 // otherwise the final cracked status shows 0/XXX progress
850
851 if (data.salts_shown[salt_pos] == 1) continue;
852 }
853
854 all_done += data.words_progress_done[salt_pos];
855 all_rejected += data.words_progress_rejected[salt_pos];
856 all_restored += data.words_progress_restored[salt_pos];
857 }
858
859 u64 progress_cur = all_restored + all_done + all_rejected;
860 u64 progress_end = progress_total;
861
862 u64 progress_skip = 0;
863
864 if (data.skip)
865 {
866 progress_skip = MIN (data.skip, data.words_base) * salts_left;
867
868 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
869 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
870 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
871 }
872
873 if (data.limit)
874 {
875 progress_end = MIN (data.limit, data.words_base) * salts_left;
876
877 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
878 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
879 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
880 }
881
882 u64 progress_cur_relative_skip = progress_cur - progress_skip;
883 u64 progress_end_relative_skip = progress_end - progress_skip;
884
885 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
886
887 /**
888 * cracks
889 */
890
891 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
892 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
893
894 /**
895 * temperature
896 */
897
898 #ifdef HAVE_HWMON
899 if (data.gpu_temp_disable == 0)
900 {
901 fprintf (out, "TEMP\t");
902
903 hc_thread_mutex_lock (mux_adl);
904
905 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
906 {
907 hc_device_param_t *device_param = &data.devices_param[device_id];
908
909 if (device_param->skipped) continue;
910
911 int temp = hm_get_temperature_with_device_id (device_id);
912
913 fprintf (out, "%d\t", temp);
914 }
915
916 hc_thread_mutex_unlock (mux_adl);
917 }
918 #endif // HAVE_HWMON
919
920 /**
921 * flush
922 */
923
924 #ifdef _WIN
925 fputc ('\r', out);
926 fputc ('\n', out);
927 #endif
928
929 #ifdef _POSIX
930 fputc ('\n', out);
931 #endif
932
933 fflush (out);
934 }
935
936 void status_display ()
937 {
938 if (data.devices_status == STATUS_INIT) return;
939 if (data.devices_status == STATUS_STARTING) return;
940 if (data.devices_status == STATUS_BYPASS) return;
941
942 if (data.status_automat == 1)
943 {
944 status_display_automat ();
945
946 return;
947 }
948
949 char tmp_buf[1000] = { 0 };
950
951 uint tmp_len = 0;
952
953 log_info ("Session.Name...: %s", data.session);
954
955 char *status_type = strstatus (data.devices_status);
956
957 uint hash_mode = data.hash_mode;
958
959 char *hash_type = strhashtype (hash_mode); // not a bug
960
961 log_info ("Status.........: %s", status_type);
962
963 /**
964 * show rules
965 */
966
967 if (data.rp_files_cnt)
968 {
969 uint i;
970
971 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
972 {
973 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
974 }
975
976 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
977
978 log_info ("Rules.Type.....: %s", tmp_buf);
979
980 tmp_len = 0;
981 }
982
983 if (data.rp_gen)
984 {
985 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
986
987 if (data.rp_gen_seed)
988 {
989 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
990 }
991 }
992
993 /**
994 * show input
995 */
996
997 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
998 {
999 if (data.wordlist_mode == WL_MODE_FILE)
1000 {
1001 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1002 }
1003 else if (data.wordlist_mode == WL_MODE_STDIN)
1004 {
1005 log_info ("Input.Mode.....: Pipe");
1006 }
1007 }
1008 else if (data.attack_mode == ATTACK_MODE_COMBI)
1009 {
1010 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1011 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1012 }
1013 else if (data.attack_mode == ATTACK_MODE_BF)
1014 {
1015 char *mask = data.mask;
1016
1017 if (mask != NULL)
1018 {
1019 uint mask_len = data.css_cnt;
1020
1021 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1022
1023 if (mask_len > 0)
1024 {
1025 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1026 {
1027 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1028 {
1029 mask_len -= data.salts_buf[0].salt_len;
1030 }
1031 }
1032
1033 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1034
1035 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1036 }
1037
1038 if (data.maskcnt > 1)
1039 {
1040 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1041
1042 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1043 }
1044
1045 log_info ("Input.Mode.....: %s", tmp_buf);
1046 }
1047
1048 tmp_len = 0;
1049 }
1050 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1051 {
1052 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1053 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1054 }
1055 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1056 {
1057 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1058 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1059 }
1060
1061 if (data.digests_cnt == 1)
1062 {
1063 if (data.hash_mode == 2500)
1064 {
1065 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1066
1067 uint pke[25] = { 0 };
1068
1069 char *pke_ptr = (char *) pke;
1070
1071 for (uint i = 0; i < 25; i++)
1072 {
1073 pke[i] = byte_swap_32 (wpa->pke[i]);
1074 }
1075
1076 char mac1[6] = { 0 };
1077 char mac2[6] = { 0 };
1078
1079 memcpy (mac1, pke_ptr + 23, 6);
1080 memcpy (mac2, pke_ptr + 29, 6);
1081
1082 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1083 (char *) data.salts_buf[0].salt_buf,
1084 mac1[0] & 0xff,
1085 mac1[1] & 0xff,
1086 mac1[2] & 0xff,
1087 mac1[3] & 0xff,
1088 mac1[4] & 0xff,
1089 mac1[5] & 0xff,
1090 mac2[0] & 0xff,
1091 mac2[1] & 0xff,
1092 mac2[2] & 0xff,
1093 mac2[3] & 0xff,
1094 mac2[4] & 0xff,
1095 mac2[5] & 0xff);
1096 }
1097 else if (data.hash_mode == 5200)
1098 {
1099 log_info ("Hash.Target....: File (%s)", data.hashfile);
1100 }
1101 else if (data.hash_mode == 9000)
1102 {
1103 log_info ("Hash.Target....: File (%s)", data.hashfile);
1104 }
1105 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1106 {
1107 log_info ("Hash.Target....: File (%s)", data.hashfile);
1108 }
1109 else
1110 {
1111 char out_buf[4096] = { 0 };
1112
1113 ascii_digest (out_buf, 0, 0);
1114
1115 // limit length
1116 if (strlen (out_buf) > 40)
1117 {
1118 out_buf[41] = '.';
1119 out_buf[42] = '.';
1120 out_buf[43] = '.';
1121 out_buf[44] = 0;
1122 }
1123
1124 log_info ("Hash.Target....: %s", out_buf);
1125 }
1126 }
1127 else
1128 {
1129 if (data.hash_mode == 3000)
1130 {
1131 char out_buf1[4096] = { 0 };
1132 char out_buf2[4096] = { 0 };
1133
1134 ascii_digest (out_buf1, 0, 0);
1135 ascii_digest (out_buf2, 0, 1);
1136
1137 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1138 }
1139 else
1140 {
1141 log_info ("Hash.Target....: File (%s)", data.hashfile);
1142 }
1143 }
1144
1145 log_info ("Hash.Type......: %s", hash_type);
1146
1147 /**
1148 * speed new
1149 */
1150
1151 u64 speed_cnt[DEVICES_MAX] = { 0 };
1152 float speed_ms[DEVICES_MAX] = { 0 };
1153
1154 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1155 {
1156 hc_device_param_t *device_param = &data.devices_param[device_id];
1157
1158 if (device_param->skipped) continue;
1159
1160 // we need to clear values (set to 0) because in case the device does
1161 // not get new candidates it idles around but speed display would
1162 // show it as working.
1163 // if we instantly set it to 0 after reading it happens that the
1164 // speed can be shown as zero if the users refreshes too fast.
1165 // therefore, we add a timestamp when a stat was recorded and if its
1166 // too old we will not use it
1167
1168 speed_cnt[device_id] = 0;
1169 speed_ms[device_id] = 0;
1170
1171 for (int i = 0; i < SPEED_CACHE; i++)
1172 {
1173 float rec_ms;
1174
1175 hc_timer_get (device_param->speed_rec[i], rec_ms);
1176
1177 if (rec_ms > SPEED_MAXAGE) continue;
1178
1179 speed_cnt[device_id] += device_param->speed_cnt[i];
1180 speed_ms[device_id] += device_param->speed_ms[i];
1181 }
1182
1183 speed_cnt[device_id] /= SPEED_CACHE;
1184 speed_ms[device_id] /= SPEED_CACHE;
1185 }
1186
1187 float hashes_all_ms = 0;
1188
1189 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1190
1191 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1192 {
1193 hc_device_param_t *device_param = &data.devices_param[device_id];
1194
1195 if (device_param->skipped) continue;
1196
1197 hashes_dev_ms[device_id] = 0;
1198
1199 if (speed_ms[device_id])
1200 {
1201 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1202
1203 hashes_all_ms += hashes_dev_ms[device_id];
1204 }
1205 }
1206
1207 /**
1208 * exec time
1209 */
1210
1211 double exec_all_ms[DEVICES_MAX] = { 0 };
1212
1213 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1214 {
1215 hc_device_param_t *device_param = &data.devices_param[device_id];
1216
1217 if (device_param->skipped) continue;
1218
1219 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1220
1221 exec_all_ms[device_id] = exec_ms_avg;
1222 }
1223
1224 /**
1225 * timers
1226 */
1227
1228 float ms_running = 0;
1229
1230 hc_timer_get (data.timer_running, ms_running);
1231
1232 float ms_paused = data.ms_paused;
1233
1234 if (data.devices_status == STATUS_PAUSED)
1235 {
1236 float ms_paused_tmp = 0;
1237
1238 hc_timer_get (data.timer_paused, ms_paused_tmp);
1239
1240 ms_paused += ms_paused_tmp;
1241 }
1242
1243 #ifdef WIN
1244
1245 __time64_t sec_run = ms_running / 1000;
1246
1247 #else
1248
1249 time_t sec_run = ms_running / 1000;
1250
1251 #endif
1252
1253 if (sec_run)
1254 {
1255 char display_run[32] = { 0 };
1256
1257 struct tm tm_run;
1258
1259 struct tm *tmp = NULL;
1260
1261 #ifdef WIN
1262
1263 tmp = _gmtime64 (&sec_run);
1264
1265 #else
1266
1267 tmp = gmtime (&sec_run);
1268
1269 #endif
1270
1271 if (tmp != NULL)
1272 {
1273 memset (&tm_run, 0, sizeof (tm_run));
1274
1275 memcpy (&tm_run, tmp, sizeof (tm_run));
1276
1277 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1278
1279 char *start = ctime (&data.proc_start);
1280
1281 size_t start_len = strlen (start);
1282
1283 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1284 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1285
1286 log_info ("Time.Started...: %s (%s)", start, display_run);
1287 }
1288 }
1289 else
1290 {
1291 log_info ("Time.Started...: 0 secs");
1292 }
1293
1294 /**
1295 * counters
1296 */
1297
1298 uint salts_left = data.salts_cnt - data.salts_done;
1299
1300 if (salts_left == 0) salts_left = 1;
1301
1302 u64 progress_total = data.words_cnt * salts_left;
1303
1304 u64 all_done = 0;
1305 u64 all_rejected = 0;
1306 u64 all_restored = 0;
1307
1308 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1309 {
1310 if (salts_left > 1)
1311 {
1312 // otherwise the final cracked status shows 0/XXX progress
1313
1314 if (data.salts_shown[salt_pos] == 1) continue;
1315 }
1316
1317 all_done += data.words_progress_done[salt_pos];
1318 all_rejected += data.words_progress_rejected[salt_pos];
1319 all_restored += data.words_progress_restored[salt_pos];
1320 }
1321
1322 u64 progress_cur = all_restored + all_done + all_rejected;
1323 u64 progress_end = progress_total;
1324
1325 u64 progress_skip = 0;
1326
1327 if (data.skip)
1328 {
1329 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1330
1331 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1332 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1333 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1334 }
1335
1336 if (data.limit)
1337 {
1338 progress_end = MIN (data.limit, data.words_base) * salts_left;
1339
1340 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1341 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1342 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1343 }
1344
1345 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1346 u64 progress_end_relative_skip = progress_end - progress_skip;
1347
1348 float speed_ms_real = ms_running - ms_paused;
1349 u64 speed_plains_real = all_done;
1350
1351 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1352 {
1353 if (data.devices_status != STATUS_CRACKED)
1354 {
1355 u64 words_per_ms = 0;
1356
1357 if (speed_plains_real && speed_ms_real)
1358 {
1359 words_per_ms = speed_plains_real / speed_ms_real;
1360 }
1361
1362 #ifdef WIN
1363 __time64_t sec_etc = 0;
1364 #else
1365 time_t sec_etc = 0;
1366 #endif
1367
1368 if (words_per_ms)
1369 {
1370 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1371
1372 u64 ms_left = progress_left_relative_skip / words_per_ms;
1373
1374 sec_etc = ms_left / 1000;
1375 }
1376
1377 if (sec_etc == 0)
1378 {
1379 log_info ("Time.Estimated.: 0 secs");
1380 }
1381 else if ((u64) sec_etc > ETC_MAX)
1382 {
1383 log_info ("Time.Estimated.: > 10 Years");
1384 }
1385 else
1386 {
1387 char display_etc[32] = { 0 };
1388
1389 struct tm tm_etc;
1390
1391 struct tm *tmp = NULL;
1392
1393 #ifdef WIN
1394
1395 tmp = _gmtime64 (&sec_etc);
1396
1397 #else
1398
1399 tmp = gmtime (&sec_etc);
1400
1401 #endif
1402
1403 if (tmp != NULL)
1404 {
1405 memset (&tm_etc, 0, sizeof (tm_etc));
1406
1407 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1408
1409 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1410
1411 time_t now;
1412
1413 time (&now);
1414
1415 now += sec_etc;
1416
1417 char *etc = ctime (&now);
1418
1419 size_t etc_len = strlen (etc);
1420
1421 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1422 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1423
1424 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1425 }
1426 }
1427 }
1428 }
1429
1430 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1431 {
1432 hc_device_param_t *device_param = &data.devices_param[device_id];
1433
1434 if (device_param->skipped) continue;
1435
1436 char display_dev_cur[16] = { 0 };
1437
1438 strncpy (display_dev_cur, "0.00", 4);
1439
1440 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1441
1442 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1443 }
1444
1445 char display_all_cur[16] = { 0 };
1446
1447 strncpy (display_all_cur, "0.00", 4);
1448
1449 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1450
1451 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1452
1453 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1454 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1455
1456 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);
1457
1458 // crack-per-time
1459
1460 if (data.digests_cnt > 100)
1461 {
1462 time_t now = time (NULL);
1463
1464 int cpt_cur_min = 0;
1465 int cpt_cur_hour = 0;
1466 int cpt_cur_day = 0;
1467
1468 for (int i = 0; i < CPT_BUF; i++)
1469 {
1470 const uint cracked = data.cpt_buf[i].cracked;
1471 const time_t timestamp = data.cpt_buf[i].timestamp;
1472
1473 if ((timestamp + 60) > now)
1474 {
1475 cpt_cur_min += cracked;
1476 }
1477
1478 if ((timestamp + 3600) > now)
1479 {
1480 cpt_cur_hour += cracked;
1481 }
1482
1483 if ((timestamp + 86400) > now)
1484 {
1485 cpt_cur_day += cracked;
1486 }
1487 }
1488
1489 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1490 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1491 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1492
1493 if ((data.cpt_start + 86400) < now)
1494 {
1495 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1496 cpt_cur_min,
1497 cpt_cur_hour,
1498 cpt_cur_day,
1499 cpt_avg_min,
1500 cpt_avg_hour,
1501 cpt_avg_day);
1502 }
1503 else if ((data.cpt_start + 3600) < now)
1504 {
1505 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1506 cpt_cur_min,
1507 cpt_cur_hour,
1508 cpt_avg_min,
1509 cpt_avg_hour,
1510 cpt_avg_day);
1511 }
1512 else if ((data.cpt_start + 60) < now)
1513 {
1514 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1515 cpt_cur_min,
1516 cpt_avg_min,
1517 cpt_avg_hour,
1518 cpt_avg_day);
1519 }
1520 else
1521 {
1522 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1523 cpt_avg_min,
1524 cpt_avg_hour,
1525 cpt_avg_day);
1526 }
1527 }
1528
1529 // Restore point
1530
1531 u64 restore_point = get_lowest_words_done ();
1532
1533 u64 restore_total = data.words_base;
1534
1535 float percent_restore = 0;
1536
1537 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1538
1539 if (progress_end_relative_skip)
1540 {
1541 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1542 {
1543 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1544 float percent_rejected = 0.0;
1545
1546 if (progress_cur)
1547 {
1548 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1549 }
1550
1551 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);
1552 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1553
1554 if (data.restore_disable == 0)
1555 {
1556 if (percent_finished != 1)
1557 {
1558 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1559 }
1560 }
1561 }
1562 }
1563 else
1564 {
1565 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1566 {
1567 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1568 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1569
1570 if (data.restore_disable == 0)
1571 {
1572 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1573 }
1574 }
1575 else
1576 {
1577 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1578 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1579
1580 // --restore not allowed if stdin is used -- really? why?
1581
1582 //if (data.restore_disable == 0)
1583 //{
1584 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1585 //}
1586 }
1587 }
1588
1589 #ifdef HAVE_HWMON
1590 if (data.gpu_temp_disable == 0)
1591 {
1592 hc_thread_mutex_lock (mux_adl);
1593
1594 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1595 {
1596 hc_device_param_t *device_param = &data.devices_param[device_id];
1597
1598 if (device_param->skipped) continue;
1599
1600 #define HM_STR_BUF_SIZE 255
1601
1602 if (data.hm_device[device_id].fan_supported == 1)
1603 {
1604 char utilization[HM_STR_BUF_SIZE] = { 0 };
1605 char temperature[HM_STR_BUF_SIZE] = { 0 };
1606 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1607
1608 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1609 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1610
1611 if (device_param->vendor_id == VENDOR_ID_AMD)
1612 {
1613 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1614 }
1615 else if (device_param->vendor_id == VENDOR_ID_NV)
1616 {
1617 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1618 }
1619
1620 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1621 }
1622 else
1623 {
1624 char utilization[HM_STR_BUF_SIZE] = { 0 };
1625 char temperature[HM_STR_BUF_SIZE] = { 0 };
1626
1627 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1628 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1629
1630 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1631 }
1632 }
1633
1634 hc_thread_mutex_unlock (mux_adl);
1635 }
1636 #endif // HAVE_HWMON
1637 }
1638
1639 static void status_benchmark ()
1640 {
1641 if (data.devices_status == STATUS_INIT) return;
1642 if (data.devices_status == STATUS_STARTING) return;
1643
1644 if (data.words_cnt == 0) return;
1645
1646 u64 speed_cnt[DEVICES_MAX] = { 0 };
1647 float speed_ms[DEVICES_MAX] = { 0 };
1648
1649 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1650 {
1651 hc_device_param_t *device_param = &data.devices_param[device_id];
1652
1653 if (device_param->skipped) continue;
1654
1655 speed_cnt[device_id] = 0;
1656 speed_ms[device_id] = 0;
1657
1658 for (int i = 0; i < SPEED_CACHE; i++)
1659 {
1660 speed_cnt[device_id] += device_param->speed_cnt[i];
1661 speed_ms[device_id] += device_param->speed_ms[i];
1662 }
1663
1664 speed_cnt[device_id] /= SPEED_CACHE;
1665 speed_ms[device_id] /= SPEED_CACHE;
1666 }
1667
1668 float hashes_all_ms = 0;
1669
1670 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1671
1672 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1673 {
1674 hc_device_param_t *device_param = &data.devices_param[device_id];
1675
1676 if (device_param->skipped) continue;
1677
1678 hashes_dev_ms[device_id] = 0;
1679
1680 if (speed_ms[device_id])
1681 {
1682 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1683
1684 hashes_all_ms += hashes_dev_ms[device_id];
1685 }
1686 }
1687
1688 /**
1689 * exec time
1690 */
1691
1692 double exec_all_ms[DEVICES_MAX] = { 0 };
1693
1694 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1695 {
1696 hc_device_param_t *device_param = &data.devices_param[device_id];
1697
1698 if (device_param->skipped) continue;
1699
1700 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1701
1702 exec_all_ms[device_id] = exec_ms_avg;
1703 }
1704
1705 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1706 {
1707 hc_device_param_t *device_param = &data.devices_param[device_id];
1708
1709 if (device_param->skipped) continue;
1710
1711 char display_dev_cur[16] = { 0 };
1712
1713 strncpy (display_dev_cur, "0.00", 4);
1714
1715 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1716
1717 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1718 }
1719
1720 char display_all_cur[16] = { 0 };
1721
1722 strncpy (display_all_cur, "0.00", 4);
1723
1724 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1725
1726 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1727 }
1728
1729 /**
1730 * oclHashcat -only- functions
1731 */
1732
1733 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1734 {
1735 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1736 {
1737 if (attack_kern == ATTACK_KERN_STRAIGHT)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_COMBI)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1741 else if (attack_kern == ATTACK_KERN_BF)
1742 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1743 }
1744 else
1745 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1746 }
1747
1748 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)
1749 {
1750 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1751 {
1752 if (attack_kern == ATTACK_KERN_STRAIGHT)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_COMBI)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 else if (attack_kern == ATTACK_KERN_BF)
1757 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1758 }
1759 else
1760 {
1761 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1762 }
1763 }
1764
1765 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1766 {
1767 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1768 {
1769 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1770 }
1771 else
1772 {
1773 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1774 }
1775 }
1776
1777 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)
1778 {
1779 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1780 {
1781 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1782 }
1783 else
1784 {
1785 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1786 }
1787 }
1788
1789 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1790 {
1791 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1792 }
1793
1794 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1795 {
1796 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1797 }
1798
1799 static uint convert_from_hex (char *line_buf, const uint line_len)
1800 {
1801 if (line_len & 1) return (line_len); // not in hex
1802
1803 if (data.hex_wordlist == 1)
1804 {
1805 uint i;
1806 uint j;
1807
1808 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1809 {
1810 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1811 }
1812
1813 memset (line_buf + i, 0, line_len - i);
1814
1815 return (i);
1816 }
1817 else if (line_len >= 6) // $HEX[] = 6
1818 {
1819 if (line_buf[0] != '$') return (line_len);
1820 if (line_buf[1] != 'H') return (line_len);
1821 if (line_buf[2] != 'E') return (line_len);
1822 if (line_buf[3] != 'X') return (line_len);
1823 if (line_buf[4] != '[') return (line_len);
1824 if (line_buf[line_len - 1] != ']') return (line_len);
1825
1826 uint i;
1827 uint j;
1828
1829 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1830 {
1831 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1832 }
1833
1834 memset (line_buf + i, 0, line_len - i);
1835
1836 return (i);
1837 }
1838
1839 return (line_len);
1840 }
1841
1842 static void clear_prompt ()
1843 {
1844 fputc ('\r', stdout);
1845
1846 for (size_t i = 0; i < strlen (PROMPT); i++)
1847 {
1848 fputc (' ', stdout);
1849 }
1850
1851 fputc ('\r', stdout);
1852
1853 fflush (stdout);
1854 }
1855
1856 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1857 {
1858 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);
1859 }
1860
1861 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1862 {
1863 char *outfile = data.outfile;
1864 uint quiet = data.quiet;
1865 FILE *pot_fp = data.pot_fp;
1866 uint loopback = data.loopback;
1867 uint debug_mode = data.debug_mode;
1868 char *debug_file = data.debug_file;
1869
1870 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1871 int debug_rule_len = 0; // -1 error
1872 uint debug_plain_len = 0;
1873
1874 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1875
1876 // hash
1877
1878 char out_buf[4096] = { 0 };
1879
1880 ascii_digest (out_buf, salt_pos, digest_pos);
1881
1882 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1883
1884 // plain
1885
1886 plain_t plain;
1887
1888 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);
1889
1890 uint gidvid = plain.gidvid;
1891 uint il_pos = plain.il_pos;
1892
1893 u64 crackpos = device_param->words_off;
1894
1895 uint plain_buf[16] = { 0 };
1896
1897 u8 *plain_ptr = (u8 *) plain_buf;
1898 unsigned int plain_len = 0;
1899
1900 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1901 {
1902 u64 gidd = gidvid;
1903 u64 gidm = 0;
1904
1905 pw_t pw;
1906
1907 gidd_to_pw_t (device_param, gidd, &pw);
1908
1909 for (int i = 0, j = gidm; i < 16; i++, j++)
1910 {
1911 plain_buf[i] = pw.i[j];
1912 }
1913
1914 plain_len = pw.pw_len;
1915
1916 const uint off = device_param->innerloop_pos + il_pos;
1917
1918 if (debug_mode > 0)
1919 {
1920 debug_rule_len = 0;
1921
1922 // save rule
1923 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1924 {
1925 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1926
1927 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1928 }
1929
1930 // save plain
1931 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1932 {
1933 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1934
1935 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1936
1937 debug_plain_len = plain_len;
1938 }
1939 }
1940
1941 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1942
1943 crackpos += gidvid;
1944 crackpos *= data.kernel_rules_cnt;
1945 crackpos += device_param->innerloop_pos + il_pos;
1946
1947 if (plain_len > data.pw_max) plain_len = data.pw_max;
1948 }
1949 else if (data.attack_mode == ATTACK_MODE_COMBI)
1950 {
1951 u64 gidd = gidvid;
1952 u64 gidm = 0;
1953
1954 pw_t pw;
1955
1956 gidd_to_pw_t (device_param, gidd, &pw);
1957
1958 for (int i = 0, j = gidm; i < 16; i++, j++)
1959 {
1960 plain_buf[i] = pw.i[j];
1961 }
1962
1963 plain_len = pw.pw_len;
1964
1965 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1966 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1967
1968 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1969 {
1970 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1971 }
1972 else
1973 {
1974 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1975
1976 memcpy (plain_ptr, comb_buf, comb_len);
1977 }
1978
1979 plain_len += comb_len;
1980
1981 crackpos += gidvid;
1982 crackpos *= data.combs_cnt;
1983 crackpos += device_param->innerloop_pos + il_pos;
1984
1985 if (data.pw_max != PW_DICTMAX1)
1986 {
1987 if (plain_len > data.pw_max) plain_len = data.pw_max;
1988 }
1989 }
1990 else if (data.attack_mode == ATTACK_MODE_BF)
1991 {
1992 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1993 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1994
1995 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1996 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1997
1998 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1999 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2000
2001 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2002 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2003
2004 plain_len = data.css_cnt;
2005
2006 crackpos += gidvid;
2007 crackpos *= data.bfs_cnt;
2008 crackpos += device_param->innerloop_pos + il_pos;
2009 }
2010 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2011 {
2012 u64 gidd = gidvid;
2013 u64 gidm = 0;
2014
2015 pw_t pw;
2016
2017 gidd_to_pw_t (device_param, gidd, &pw);
2018
2019 for (int i = 0, j = gidm; i < 16; i++, j++)
2020 {
2021 plain_buf[i] = pw.i[j];
2022 }
2023
2024 plain_len = pw.pw_len;
2025
2026 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2027
2028 uint start = 0;
2029 uint stop = device_param->kernel_params_mp_buf32[4];
2030
2031 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2032
2033 plain_len += start + stop;
2034
2035 crackpos += gidvid;
2036 crackpos *= data.combs_cnt;
2037 crackpos += device_param->innerloop_pos + il_pos;
2038
2039 if (data.pw_max != PW_DICTMAX1)
2040 {
2041 if (plain_len > data.pw_max) plain_len = data.pw_max;
2042 }
2043 }
2044 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2045 {
2046 u64 gidd = gidvid;
2047 u64 gidm = 0;
2048
2049 pw_t pw;
2050
2051 gidd_to_pw_t (device_param, gidd, &pw);
2052
2053 for (int i = 0, j = gidm; i < 16; i++, j++)
2054 {
2055 plain_buf[i] = pw.i[j];
2056 }
2057
2058 plain_len = pw.pw_len;
2059
2060 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2061
2062 uint start = 0;
2063 uint stop = device_param->kernel_params_mp_buf32[4];
2064
2065 memmove (plain_ptr + stop, plain_ptr, plain_len);
2066
2067 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2068
2069 plain_len += start + stop;
2070
2071 crackpos += gidvid;
2072 crackpos *= data.combs_cnt;
2073 crackpos += device_param->innerloop_pos + il_pos;
2074
2075 if (data.pw_max != PW_DICTMAX1)
2076 {
2077 if (plain_len > data.pw_max) plain_len = data.pw_max;
2078 }
2079 }
2080
2081 if (data.attack_mode == ATTACK_MODE_BF)
2082 {
2083 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2084 {
2085 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2086 {
2087 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2088 {
2089 plain_len = plain_len - data.salts_buf[0].salt_len;
2090 }
2091 }
2092
2093 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2094 {
2095 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2096 {
2097 plain_ptr[j] = plain_ptr[i];
2098 }
2099
2100 plain_len = plain_len / 2;
2101 }
2102 }
2103 }
2104
2105 // if enabled, update also the potfile
2106
2107 if (pot_fp)
2108 {
2109 lock_file (pot_fp);
2110
2111 fprintf (pot_fp, "%s:", out_buf);
2112
2113 format_plain (pot_fp, plain_ptr, plain_len, 1);
2114
2115 fputc ('\n', pot_fp);
2116
2117 fflush (pot_fp);
2118
2119 unlock_file (pot_fp);
2120 }
2121
2122 // outfile
2123
2124 FILE *out_fp = NULL;
2125
2126 if (outfile != NULL)
2127 {
2128 if ((out_fp = fopen (outfile, "ab")) == NULL)
2129 {
2130 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2131
2132 out_fp = stdout;
2133 }
2134 lock_file (out_fp);
2135 }
2136 else
2137 {
2138 out_fp = stdout;
2139
2140 if (quiet == 0) clear_prompt ();
2141 }
2142
2143 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2144
2145 if (outfile != NULL)
2146 {
2147 if (out_fp != stdout)
2148 {
2149 fclose (out_fp);
2150 }
2151 }
2152 else
2153 {
2154 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2155 {
2156 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2157 {
2158 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2159 if (quiet == 0) fflush (stdout);
2160 }
2161 }
2162 }
2163
2164 // loopback
2165
2166 if (loopback)
2167 {
2168 char *loopback_file = data.loopback_file;
2169
2170 FILE *fb_fp = NULL;
2171
2172 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2173 {
2174 lock_file (fb_fp);
2175
2176 format_plain (fb_fp, plain_ptr, plain_len, 1);
2177
2178 fputc ('\n', fb_fp);
2179
2180 fclose (fb_fp);
2181 }
2182 }
2183
2184 // (rule) debug mode
2185
2186 // the next check implies that:
2187 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2188 // - debug_mode > 0
2189
2190 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2191 {
2192 if (debug_rule_len < 0) debug_rule_len = 0;
2193
2194 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2195
2196 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2197
2198 if ((quiet == 0) && (debug_file == NULL))
2199 {
2200 fprintf (stdout, "%s", PROMPT);
2201 fflush (stdout);
2202 }
2203 }
2204 }
2205
2206 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2207 {
2208 salt_t *salt_buf = &data.salts_buf[salt_pos];
2209
2210 int found = 0;
2211
2212 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);
2213
2214 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2215
2216 if (found == 1)
2217 {
2218 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2219
2220 log_info_nn ("");
2221
2222 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);
2223
2224 uint cpt_cracked = 0;
2225
2226 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2227 {
2228 uint idx = salt_buf->digests_offset + digest_pos;
2229
2230 if (data.digests_shown_tmp[idx] == 0) continue;
2231
2232 if (data.digests_shown[idx] == 1) continue;
2233
2234 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2235 {
2236 data.digests_shown[idx] = 1;
2237
2238 data.digests_done++;
2239
2240 cpt_cracked++;
2241
2242 salt_buf->digests_done++;
2243
2244 if (salt_buf->digests_done == salt_buf->digests_cnt)
2245 {
2246 data.salts_shown[salt_pos] = 1;
2247
2248 data.salts_done++;
2249 }
2250 }
2251
2252 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2253
2254 check_hash (device_param, salt_pos, digest_pos);
2255 }
2256
2257 if (cpt_cracked > 0)
2258 {
2259 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2260 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2261
2262 data.cpt_pos++;
2263
2264 data.cpt_total += cpt_cracked;
2265
2266 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2267 }
2268
2269 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2270 {
2271 // we need to reset cracked state on the device
2272 // otherwise host thinks again and again the hash was cracked
2273 // and returns invalid password each time
2274
2275 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2276
2277 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);
2278 }
2279
2280 memset (device_param->result, 0, device_param->size_results);
2281
2282 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);
2283 }
2284 }
2285
2286 static void save_hash ()
2287 {
2288 char *hashfile = data.hashfile;
2289
2290 char new_hashfile[256] = { 0 };
2291 char old_hashfile[256] = { 0 };
2292
2293 snprintf (new_hashfile, 255, "%s.new", hashfile);
2294 snprintf (old_hashfile, 255, "%s.old", hashfile);
2295
2296 unlink (new_hashfile);
2297
2298 char separator = data.separator;
2299
2300 FILE *fp = fopen (new_hashfile, "wb");
2301
2302 if (fp == NULL)
2303 {
2304 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2305
2306 exit (-1);
2307 }
2308
2309 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2310 {
2311 if (data.salts_shown[salt_pos] == 1) continue;
2312
2313 salt_t *salt_buf = &data.salts_buf[salt_pos];
2314
2315 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2316 {
2317 uint idx = salt_buf->digests_offset + digest_pos;
2318
2319 if (data.digests_shown[idx] == 1) continue;
2320
2321 if (data.hash_mode != 2500)
2322 {
2323 char out_buf[4096] = { 0 };
2324
2325 if (data.username == 1)
2326 {
2327 user_t *user = data.hash_info[idx]->user;
2328
2329 uint i;
2330
2331 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2332
2333 fputc (separator, fp);
2334 }
2335
2336 ascii_digest (out_buf, salt_pos, digest_pos);
2337
2338 fputs (out_buf, fp);
2339
2340 log_out (fp, "");
2341 }
2342 else
2343 {
2344 hccap_t hccap;
2345
2346 to_hccap_t (&hccap, salt_pos, digest_pos);
2347
2348 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2349 }
2350 }
2351 }
2352
2353 fflush (fp);
2354
2355 fclose (fp);
2356
2357 unlink (old_hashfile);
2358
2359 if (rename (hashfile, old_hashfile) != 0)
2360 {
2361 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2362
2363 exit (-1);
2364 }
2365
2366 unlink (hashfile);
2367
2368 if (rename (new_hashfile, hashfile) != 0)
2369 {
2370 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2371
2372 exit (-1);
2373 }
2374
2375 unlink (old_hashfile);
2376 }
2377
2378 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2379 {
2380 // function called only in case kernel_power_all > words_left
2381
2382 float kernel_power_div = (float) (total_left) / kernel_power_all;
2383
2384 kernel_power_div += kernel_power_div / 100;
2385
2386 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2387
2388 while (kernel_power_new < total_left)
2389 {
2390 kernel_power_div += kernel_power_div / 100;
2391
2392 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2393 }
2394
2395 if (data.quiet == 0)
2396 {
2397 clear_prompt ();
2398
2399 log_info ("");
2400
2401 log_info ("INFO: approaching final keyspace, workload adjusted");
2402
2403 log_info ("");
2404
2405 fprintf (stdout, "%s", PROMPT);
2406
2407 fflush (stdout);
2408 }
2409
2410 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2411
2412 return kernel_power_div;
2413 }
2414
2415 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2416 {
2417 uint num_elements = num;
2418
2419 device_param->kernel_params_buf32[30] = data.combs_mode;
2420 device_param->kernel_params_buf32[31] = num;
2421
2422 uint kernel_threads = device_param->kernel_threads;
2423
2424 while (num_elements % kernel_threads) num_elements++;
2425
2426 cl_kernel kernel = NULL;
2427
2428 switch (kern_run)
2429 {
2430 case KERN_RUN_1: kernel = device_param->kernel1; break;
2431 case KERN_RUN_12: kernel = device_param->kernel12; break;
2432 case KERN_RUN_2: kernel = device_param->kernel2; break;
2433 case KERN_RUN_23: kernel = device_param->kernel23; break;
2434 case KERN_RUN_3: kernel = device_param->kernel3; break;
2435 }
2436
2437 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2438 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2439 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2440 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2441 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2442 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2443 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2444 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2445 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2446 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2447 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2448
2449 hc_timer_t timer;
2450
2451 hc_timer_set (&timer);
2452
2453 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2454 {
2455 const size_t global_work_size[3] = { num_elements, 32, 1 };
2456 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2457
2458 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2459 }
2460 else
2461 {
2462 size_t workgroup_size = 0;
2463
2464 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2465
2466 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2467
2468 const size_t global_work_size[3] = { num_elements, 1, 1 };
2469 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2470
2471 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2472 }
2473
2474 hc_clFlush (data.ocl, device_param->command_queue);
2475
2476 hc_clFinish (data.ocl, device_param->command_queue);
2477
2478 if (event_update)
2479 {
2480 float exec_time;
2481
2482 hc_timer_get (timer, exec_time);
2483
2484 uint exec_pos = device_param->exec_pos;
2485
2486 device_param->exec_ms[exec_pos] = exec_time;
2487
2488 exec_pos++;
2489
2490 if (exec_pos == EXEC_CACHE)
2491 {
2492 exec_pos = 0;
2493 }
2494
2495 device_param->exec_pos = exec_pos;
2496 }
2497 }
2498
2499 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2500 {
2501 uint num_elements = num;
2502
2503 switch (kern_run)
2504 {
2505 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2506 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2507 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2508 }
2509
2510 // causes problems with special threads like in bcrypt
2511 // const uint kernel_threads = device_param->kernel_threads;
2512
2513 uint kernel_threads = KERNEL_THREADS;
2514
2515 while (num_elements % kernel_threads) num_elements++;
2516
2517 cl_kernel kernel = NULL;
2518
2519 switch (kern_run)
2520 {
2521 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2522 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2523 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2524 }
2525
2526 switch (kern_run)
2527 {
2528 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2529 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2530 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2531 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2532 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2533 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2534 break;
2535 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2536 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2537 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2538 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2539 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2540 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2541 break;
2542 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2543 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2544 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2545 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2546 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2547 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2548 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2549 break;
2550 }
2551
2552 size_t workgroup_size = 0;
2553 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2554 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2555
2556 const size_t global_work_size[3] = { num_elements, 1, 1 };
2557 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2558
2559 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2560
2561 hc_clFlush (data.ocl, device_param->command_queue);
2562
2563 hc_clFinish (data.ocl, device_param->command_queue);
2564 }
2565
2566 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2567 {
2568 uint num_elements = num;
2569
2570 uint kernel_threads = device_param->kernel_threads;
2571
2572 while (num_elements % kernel_threads) num_elements++;
2573
2574 cl_kernel kernel = device_param->kernel_tb;
2575
2576 size_t workgroup_size = 0;
2577 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2578 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2579
2580 const size_t global_work_size[3] = { num_elements, 1, 1 };
2581 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2582
2583 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2584
2585 hc_clFlush (data.ocl, device_param->command_queue);
2586
2587 hc_clFinish (data.ocl, device_param->command_queue);
2588 }
2589
2590 static void run_kernel_tm (hc_device_param_t *device_param)
2591 {
2592 const uint num_elements = 1024; // fixed
2593
2594 uint kernel_threads = 32;
2595
2596 cl_kernel kernel = device_param->kernel_tm;
2597
2598 size_t workgroup_size = 0;
2599 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2600 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2601
2602 const size_t global_work_size[3] = { num_elements, 1, 1 };
2603 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2604
2605 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2606
2607 hc_clFlush (data.ocl, device_param->command_queue);
2608
2609 hc_clFinish (data.ocl, device_param->command_queue);
2610 }
2611
2612 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2613 {
2614 uint num_elements = num;
2615
2616 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2617 device_param->kernel_params_amp_buf32[6] = num_elements;
2618
2619 // causes problems with special threads like in bcrypt
2620 // const uint kernel_threads = device_param->kernel_threads;
2621
2622 uint kernel_threads = KERNEL_THREADS;
2623
2624 while (num_elements % kernel_threads) num_elements++;
2625
2626 cl_kernel kernel = device_param->kernel_amp;
2627
2628 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2629 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2630
2631 size_t workgroup_size = 0;
2632 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2633 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2634
2635 const size_t global_work_size[3] = { num_elements, 1, 1 };
2636 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2637
2638 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2639
2640 hc_clFlush (data.ocl, device_param->command_queue);
2641
2642 hc_clFinish (data.ocl, device_param->command_queue);
2643 }
2644
2645 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2646 {
2647 int rc = -1;
2648
2649 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2650 {
2651 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2652
2653 const cl_uchar zero = 0;
2654
2655 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2656 }
2657
2658 if (rc != 0)
2659 {
2660 // NOTE: clEnqueueFillBuffer () always fails with -59
2661 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2662 // How's that possible, OpenCL 1.2 support is advertised??
2663 // We need to workaround...
2664
2665 #define FILLSZ 0x100000
2666
2667 char *tmp = (char *) mymalloc (FILLSZ);
2668
2669 for (uint i = 0; i < size; i += FILLSZ)
2670 {
2671 const int left = size - i;
2672
2673 const int fillsz = MIN (FILLSZ, left);
2674
2675 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2676 }
2677
2678 myfree (tmp);
2679 }
2680 }
2681
2682 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)
2683 {
2684 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2685 {
2686 if (attack_mode == ATTACK_MODE_BF)
2687 {
2688 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2689 {
2690 const uint size_tm = 32 * sizeof (bs_word_t);
2691
2692 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2693
2694 run_kernel_tm (device_param);
2695
2696 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);
2697 }
2698 }
2699
2700 if (highest_pw_len < 16)
2701 {
2702 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2703 }
2704 else if (highest_pw_len < 32)
2705 {
2706 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2707 }
2708 else
2709 {
2710 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2711 }
2712 }
2713 else
2714 {
2715 run_kernel_amp (device_param, pws_cnt);
2716
2717 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2718
2719 if (opts_type & OPTS_TYPE_HOOK12)
2720 {
2721 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2722 }
2723
2724 uint iter = salt_buf->salt_iter;
2725
2726 uint loop_step = device_param->kernel_loops;
2727
2728 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2729 {
2730 uint loop_left = iter - loop_pos;
2731
2732 loop_left = MIN (loop_left, loop_step);
2733
2734 device_param->kernel_params_buf32[25] = loop_pos;
2735 device_param->kernel_params_buf32[26] = loop_left;
2736
2737 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2738
2739 if (data.devices_status == STATUS_CRACKED) break;
2740 if (data.devices_status == STATUS_ABORTED) break;
2741 if (data.devices_status == STATUS_QUIT) break;
2742 }
2743
2744 if (opts_type & OPTS_TYPE_HOOK23)
2745 {
2746 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2747
2748 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);
2749
2750 // do something with data
2751
2752 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);
2753 }
2754
2755 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2756 }
2757 }
2758
2759 static int run_rule_engine (const int rule_len, const char *rule_buf)
2760 {
2761 if (rule_len == 0)
2762 {
2763 return 0;
2764 }
2765 else if (rule_len == 1)
2766 {
2767 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2768 }
2769
2770 return 1;
2771 }
2772
2773 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2774 {
2775 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2776 {
2777 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);
2778 }
2779 else if (data.attack_kern == ATTACK_KERN_COMBI)
2780 {
2781 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2782 {
2783 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2784 {
2785 for (u32 i = 0; i < pws_cnt; i++)
2786 {
2787 const u32 pw_len = device_param->pws_buf[i].pw_len;
2788
2789 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2790
2791 ptr[pw_len] = 0x01;
2792 }
2793 }
2794 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2795 {
2796 for (u32 i = 0; i < pws_cnt; i++)
2797 {
2798 const u32 pw_len = device_param->pws_buf[i].pw_len;
2799
2800 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2801
2802 ptr[pw_len] = 0x80;
2803 }
2804 }
2805 }
2806
2807 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);
2808 }
2809 else if (data.attack_kern == ATTACK_KERN_BF)
2810 {
2811 const u64 off = device_param->words_off;
2812
2813 device_param->kernel_params_mp_l_buf64[3] = off;
2814
2815 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2816 }
2817 }
2818
2819 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2820 {
2821 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2822
2823 device_param->kernel_params_buf32[26] = kernel_loops;
2824 device_param->kernel_params_buf32[27] = kernel_loops;
2825
2826 // init some fake words
2827
2828 for (u32 i = 0; i < kernel_power; i++)
2829 {
2830 device_param->pws_buf[i].i[0] = i;
2831 device_param->pws_buf[i].i[1] = 0x01234567;
2832 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2833 }
2834
2835 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);
2836
2837 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2838 {
2839 run_kernel_amp (device_param, kernel_power);
2840 }
2841
2842 // caching run
2843
2844 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2845 {
2846 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2847 }
2848 else
2849 {
2850 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2851 }
2852
2853 // now user repeats
2854
2855 for (int i = 0; i < repeat; i++)
2856 {
2857 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2858 {
2859 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2860 }
2861 else
2862 {
2863 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2864 }
2865 }
2866
2867 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2868
2869 // reset fake words
2870
2871 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2872
2873 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);
2874 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);
2875
2876 return exec_ms_prev;
2877 }
2878
2879 static void autotune (hc_device_param_t *device_param)
2880 {
2881 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2882
2883 const u32 kernel_accel_min = device_param->kernel_accel_min;
2884 const u32 kernel_accel_max = device_param->kernel_accel_max;
2885
2886 const u32 kernel_loops_min = device_param->kernel_loops_min;
2887 const u32 kernel_loops_max = device_param->kernel_loops_max;
2888
2889 u32 kernel_accel = kernel_accel_min;
2890 u32 kernel_loops = kernel_loops_min;
2891
2892 // steps
2893
2894 #define STEPS_CNT 10
2895
2896 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2897 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2898
2899 u32 steps_accel[STEPS_ACCEL_CNT];
2900 u32 steps_loops[STEPS_LOOPS_CNT];
2901
2902 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2903 {
2904 steps_accel[i] = 1 << i;
2905 }
2906
2907 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2908 {
2909 steps_loops[i] = 1 << i;
2910 }
2911
2912 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2913 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2914
2915 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2916 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2917
2918 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2919 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2920
2921 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2922
2923 u32 kernel_loops_tmp;
2924
2925 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2926 {
2927 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2928
2929 if (exec_ms < target_ms) break;
2930 }
2931
2932 // kernel-accel
2933
2934 if (kernel_accel_min < kernel_accel_max)
2935 {
2936 double e_best = 0;
2937
2938 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2939 {
2940 const u32 kernel_accel_try = steps_accel[i];
2941
2942 if (kernel_accel_try < kernel_accel_min) continue;
2943 if (kernel_accel_try > kernel_accel_max) break;
2944
2945 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2946
2947 if (exec_ms > target_ms) break;
2948
2949 const double e = kernel_accel_try / exec_ms;
2950
2951 if (e > e_best)
2952 {
2953 kernel_accel = kernel_accel_try;
2954
2955 e_best = e;
2956 }
2957 }
2958 }
2959
2960 // kernel-loops final
2961
2962 if (kernel_loops_min < kernel_loops_max)
2963 {
2964 double e_best = 0;
2965
2966 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2967 {
2968 const u32 kernel_loops_try = steps_loops[i];
2969
2970 if (kernel_loops_try < kernel_loops_min) continue;
2971 if (kernel_loops_try > kernel_loops_max) break;
2972
2973 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2974
2975 if (exec_ms > target_ms) break;
2976
2977 const double e = kernel_loops_try / exec_ms;
2978
2979 if (e > e_best)
2980 {
2981 kernel_loops = kernel_loops_try;
2982
2983 e_best = e;
2984 }
2985 }
2986 }
2987
2988 // final balance
2989
2990 u32 kernel_accel_best = kernel_accel;
2991 u32 kernel_loops_best = kernel_loops;
2992
2993 u32 exec_best = -1;
2994
2995 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2996 {
2997 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2998
2999 exec_best = exec_ms;
3000 }
3001
3002 // reset
3003
3004 if (kernel_accel_min < kernel_accel_max)
3005 {
3006 u32 kernel_accel_try = kernel_accel;
3007 u32 kernel_loops_try = kernel_loops;
3008
3009 for (int i = 0; i < 2; i++)
3010 {
3011 kernel_accel_try >>= 1;
3012 kernel_loops_try <<= 1;
3013
3014 if (kernel_accel_try < kernel_accel_min) break;
3015 if (kernel_loops_try > kernel_loops_max) break;
3016
3017 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3018
3019 if (exec_ms < exec_best)
3020 {
3021 kernel_accel_best = kernel_accel_try;
3022 kernel_loops_best = kernel_loops_try;
3023
3024 exec_best = exec_ms;
3025 }
3026 }
3027 }
3028
3029 // reset
3030
3031 if (kernel_loops_min < kernel_loops_max)
3032 {
3033 u32 kernel_accel_try = kernel_accel;
3034 u32 kernel_loops_try = kernel_loops;
3035
3036 for (int i = 0; i < 2; i++)
3037 {
3038 kernel_accel_try <<= 1;
3039 kernel_loops_try >>= 1;
3040
3041 if (kernel_accel_try > kernel_accel_max) break;
3042 if (kernel_loops_try < kernel_loops_min) break;
3043
3044 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3045
3046 if (exec_ms < exec_best)
3047 {
3048 kernel_accel_best = kernel_accel_try;
3049 kernel_loops_best = kernel_loops_try;
3050
3051 exec_best = exec_ms;
3052 }
3053 }
3054 }
3055
3056 // reset timer
3057
3058 device_param->exec_pos = 0;
3059
3060 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3061
3062 // store
3063
3064 kernel_accel = kernel_accel_best;
3065 kernel_loops = kernel_loops_best;
3066
3067 device_param->kernel_accel = kernel_accel;
3068 device_param->kernel_loops = kernel_loops;
3069
3070 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3071
3072 device_param->kernel_power = kernel_power;
3073
3074 if (data.quiet == 0) log_info ("Device #%u: autotuned kernel-accel to %u", device_param->device_id + 1, kernel_accel);
3075 if (data.quiet == 0) log_info ("Device #%u: autotuned kernel-loops to %u", device_param->device_id + 1, kernel_loops);
3076 if (data.quiet == 0) log_info ("");
3077 }
3078
3079 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3080 {
3081 // init speed timer
3082
3083 uint speed_pos = device_param->speed_pos;
3084
3085 #ifdef _POSIX
3086 if (device_param->timer_speed.tv_sec == 0)
3087 {
3088 hc_timer_set (&device_param->timer_speed);
3089 }
3090 #endif
3091
3092 #ifdef _WIN
3093 if (device_param->timer_speed.QuadPart == 0)
3094 {
3095 hc_timer_set (&device_param->timer_speed);
3096 }
3097 #endif
3098
3099 // find higest password length, this is for optimization stuff
3100
3101 uint highest_pw_len = 0;
3102
3103 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3104 {
3105 }
3106 else if (data.attack_kern == ATTACK_KERN_COMBI)
3107 {
3108 }
3109 else if (data.attack_kern == ATTACK_KERN_BF)
3110 {
3111 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3112 + device_param->kernel_params_mp_l_buf32[5];
3113 }
3114
3115 // bitslice optimization stuff
3116
3117 if (data.attack_mode == ATTACK_MODE_BF)
3118 {
3119 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3120 {
3121 run_kernel_tb (device_param, pws_cnt);
3122 }
3123 }
3124
3125 // iteration type
3126
3127 uint innerloop_step = 0;
3128 uint innerloop_cnt = 0;
3129
3130 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3131 else innerloop_step = 1;
3132
3133 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3134 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3135 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3136
3137 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3138
3139 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3140 {
3141 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3142
3143 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3144
3145 if (data.devices_status == STATUS_CRACKED) break;
3146 if (data.devices_status == STATUS_ABORTED) break;
3147 if (data.devices_status == STATUS_QUIT) break;
3148 if (data.devices_status == STATUS_BYPASS) break;
3149
3150 if (data.salts_shown[salt_pos] == 1) continue;
3151
3152 salt_t *salt_buf = &data.salts_buf[salt_pos];
3153
3154 device_param->kernel_params_buf32[24] = salt_pos;
3155 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3156 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3157
3158 FILE *combs_fp = device_param->combs_fp;
3159
3160 if (data.attack_mode == ATTACK_MODE_COMBI)
3161 {
3162 rewind (combs_fp);
3163 }
3164
3165 // innerloops
3166
3167 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3168 {
3169 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3170
3171 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3172
3173 if (data.devices_status == STATUS_CRACKED) break;
3174 if (data.devices_status == STATUS_ABORTED) break;
3175 if (data.devices_status == STATUS_QUIT) break;
3176 if (data.devices_status == STATUS_BYPASS) break;
3177
3178 uint innerloop_left = innerloop_cnt - innerloop_pos;
3179
3180 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3181
3182 device_param->innerloop_pos = innerloop_pos;
3183 device_param->innerloop_left = innerloop_left;
3184
3185 device_param->kernel_params_buf32[27] = innerloop_left;
3186
3187 // i think we can get rid of this
3188 if (innerloop_left == 0)
3189 {
3190 puts ("bug, how should this happen????\n");
3191
3192 continue;
3193 }
3194
3195 // initialize amplifiers
3196
3197 if (data.attack_mode == ATTACK_MODE_COMBI)
3198 {
3199 char line_buf[BUFSIZ] = { 0 };
3200
3201 uint i = 0;
3202
3203 while (i < innerloop_left)
3204 {
3205 if (feof (combs_fp)) break;
3206
3207 int line_len = fgetl (combs_fp, line_buf);
3208
3209 if (line_len >= PW_MAX1) continue;
3210
3211 line_len = convert_from_hex (line_buf, line_len);
3212
3213 char *line_buf_new = line_buf;
3214
3215 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3216 {
3217 char rule_buf_out[BLOCK_SIZE] = { 0 };
3218
3219 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3220
3221 if (rule_len_out < 0)
3222 {
3223 data.words_progress_rejected[salt_pos] += pws_cnt;
3224
3225 continue;
3226 }
3227
3228 line_len = rule_len_out;
3229
3230 line_buf_new = rule_buf_out;
3231 }
3232
3233 line_len = MIN (line_len, PW_DICTMAX);
3234
3235 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3236
3237 memcpy (ptr, line_buf_new, line_len);
3238
3239 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3240
3241 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3242 {
3243 uppercase (ptr, line_len);
3244 }
3245
3246 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3247 {
3248 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3249 {
3250 ptr[line_len] = 0x80;
3251 }
3252
3253 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3254 {
3255 ptr[line_len] = 0x01;
3256 }
3257 }
3258
3259 device_param->combs_buf[i].pw_len = line_len;
3260
3261 i++;
3262 }
3263
3264 for (uint j = i; j < innerloop_left; j++)
3265 {
3266 device_param->combs_buf[j].i[0] = 0;
3267 device_param->combs_buf[j].i[1] = 0;
3268 device_param->combs_buf[j].i[2] = 0;
3269 device_param->combs_buf[j].i[3] = 0;
3270 device_param->combs_buf[j].i[4] = 0;
3271 device_param->combs_buf[j].i[5] = 0;
3272 device_param->combs_buf[j].i[6] = 0;
3273 device_param->combs_buf[j].i[7] = 0;
3274
3275 device_param->combs_buf[j].pw_len = 0;
3276 }
3277
3278 innerloop_left = i;
3279 }
3280 else if (data.attack_mode == ATTACK_MODE_BF)
3281 {
3282 u64 off = innerloop_pos;
3283
3284 device_param->kernel_params_mp_r_buf64[3] = off;
3285
3286 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3287 }
3288 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3289 {
3290 u64 off = innerloop_pos;
3291
3292 device_param->kernel_params_mp_buf64[3] = off;
3293
3294 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3295 }
3296 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3297 {
3298 u64 off = innerloop_pos;
3299
3300 device_param->kernel_params_mp_buf64[3] = off;
3301
3302 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3303 }
3304
3305 // copy amplifiers
3306
3307 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3308 {
3309 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);
3310 }
3311 else if (data.attack_mode == ATTACK_MODE_COMBI)
3312 {
3313 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);
3314 }
3315 else if (data.attack_mode == ATTACK_MODE_BF)
3316 {
3317 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);
3318 }
3319 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3320 {
3321 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);
3322 }
3323 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3324 {
3325 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);
3326 }
3327
3328 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3329
3330 if (data.benchmark == 1)
3331 {
3332 for (u32 i = 0; i < data.benchmark_repeats; i++)
3333 {
3334 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3335 }
3336 }
3337
3338 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3339
3340 if (data.devices_status == STATUS_CRACKED) break;
3341 if (data.devices_status == STATUS_ABORTED) break;
3342 if (data.devices_status == STATUS_QUIT) break;
3343
3344 /**
3345 * result
3346 */
3347
3348 hc_thread_mutex_lock (mux_display);
3349
3350 check_cracked (device_param, salt_pos);
3351
3352 hc_thread_mutex_unlock (mux_display);
3353
3354 /**
3355 * progress
3356 */
3357
3358 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3359
3360 if (data.benchmark == 1)
3361 {
3362 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3363 }
3364
3365 hc_thread_mutex_lock (mux_counter);
3366
3367 data.words_progress_done[salt_pos] += perf_sum_all;
3368
3369 hc_thread_mutex_unlock (mux_counter);
3370
3371 /**
3372 * speed
3373 */
3374
3375 float speed_ms;
3376
3377 hc_timer_get (device_param->timer_speed, speed_ms);
3378
3379 hc_timer_set (&device_param->timer_speed);
3380
3381 hc_thread_mutex_lock (mux_display);
3382
3383 device_param->speed_cnt[speed_pos] = perf_sum_all;
3384
3385 device_param->speed_ms[speed_pos] = speed_ms;
3386
3387 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3388
3389 hc_thread_mutex_unlock (mux_display);
3390
3391 speed_pos++;
3392
3393 if (speed_pos == SPEED_CACHE)
3394 {
3395 speed_pos = 0;
3396 }
3397
3398 /**
3399 * benchmark
3400 */
3401
3402 if (data.benchmark == 1) break;
3403 }
3404 }
3405
3406 device_param->speed_pos = speed_pos;
3407 }
3408
3409 static void load_segment (wl_data_t *wl_data, FILE *fd)
3410 {
3411 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3412
3413 wl_data->pos = 0;
3414
3415 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3416
3417 wl_data->buf[wl_data->cnt] = 0;
3418
3419 if (wl_data->cnt == 0) return;
3420
3421 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3422
3423 while (!feof (fd))
3424 {
3425 if (wl_data->cnt == wl_data->avail)
3426 {
3427 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3428
3429 wl_data->avail += wl_data->incr;
3430 }
3431
3432 const int c = fgetc (fd);
3433
3434 if (c == EOF) break;
3435
3436 wl_data->buf[wl_data->cnt] = (char) c;
3437
3438 wl_data->cnt++;
3439
3440 if (c == '\n') break;
3441 }
3442
3443 // ensure stream ends with a newline
3444
3445 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3446 {
3447 wl_data->cnt++;
3448
3449 wl_data->buf[wl_data->cnt - 1] = '\n';
3450 }
3451
3452 return;
3453 }
3454
3455 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3456 {
3457 char *ptr = buf;
3458
3459 for (u32 i = 0; i < sz; i++, ptr++)
3460 {
3461 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3462
3463 if (i == 7)
3464 {
3465 *off = i;
3466 *len = i;
3467
3468 return;
3469 }
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_uc (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 >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3493
3494 if (*ptr != '\n') continue;
3495
3496 *off = i + 1;
3497
3498 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3499
3500 *len = i;
3501
3502 return;
3503 }
3504
3505 *off = sz;
3506 *len = sz;
3507 }
3508
3509 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3510 {
3511 char *ptr = buf;
3512
3513 for (u32 i = 0; i < sz; i++, ptr++)
3514 {
3515 if (*ptr != '\n') continue;
3516
3517 *off = i + 1;
3518
3519 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3520
3521 *len = i;
3522
3523 return;
3524 }
3525
3526 *off = sz;
3527 *len = sz;
3528 }
3529
3530 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3531 {
3532 while (wl_data->pos < wl_data->cnt)
3533 {
3534 uint off;
3535 uint len;
3536
3537 char *ptr = wl_data->buf + wl_data->pos;
3538
3539 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3540
3541 wl_data->pos += off;
3542
3543 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3544 {
3545 char rule_buf_out[BLOCK_SIZE] = { 0 };
3546
3547 int rule_len_out = -1;
3548
3549 if (len < BLOCK_SIZE)
3550 {
3551 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3552 }
3553
3554 if (rule_len_out < 0)
3555 {
3556 continue;
3557 }
3558
3559 if (rule_len_out > PW_MAX)
3560 {
3561 continue;
3562 }
3563 }
3564 else
3565 {
3566 if (len > PW_MAX)
3567 {
3568 continue;
3569 }
3570 }
3571
3572 *out_buf = ptr;
3573 *out_len = len;
3574
3575 return;
3576 }
3577
3578 if (feof (fd))
3579 {
3580 fprintf (stderr, "BUG feof()!!\n");
3581
3582 return;
3583 }
3584
3585 load_segment (wl_data, fd);
3586
3587 get_next_word (wl_data, fd, out_buf, out_len);
3588 }
3589
3590 #ifdef _POSIX
3591 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3592 #endif
3593
3594 #ifdef _WIN
3595 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3596 #endif
3597 {
3598 hc_signal (NULL);
3599
3600 dictstat_t d;
3601
3602 d.cnt = 0;
3603
3604 #ifdef _POSIX
3605 fstat (fileno (fd), &d.stat);
3606 #endif
3607
3608 #ifdef _WIN
3609 _fstat64 (fileno (fd), &d.stat);
3610 #endif
3611
3612 d.stat.st_mode = 0;
3613 d.stat.st_nlink = 0;
3614 d.stat.st_uid = 0;
3615 d.stat.st_gid = 0;
3616 d.stat.st_rdev = 0;
3617 d.stat.st_atime = 0;
3618
3619 #ifdef _POSIX
3620 d.stat.st_blksize = 0;
3621 d.stat.st_blocks = 0;
3622 #endif
3623
3624 if (d.stat.st_size == 0) return 0;
3625
3626 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3627
3628 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3629 {
3630 if (d_cache)
3631 {
3632 u64 cnt = d_cache->cnt;
3633
3634 u64 keyspace = cnt;
3635
3636 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3637 {
3638 keyspace *= data.kernel_rules_cnt;
3639 }
3640 else if (data.attack_kern == ATTACK_KERN_COMBI)
3641 {
3642 keyspace *= data.combs_cnt;
3643 }
3644
3645 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);
3646 if (data.quiet == 0) log_info ("");
3647
3648 hc_signal (sigHandler_default);
3649
3650 return (keyspace);
3651 }
3652 }
3653
3654 time_t now = 0;
3655 time_t prev = 0;
3656
3657 u64 comp = 0;
3658 u64 cnt = 0;
3659 u64 cnt2 = 0;
3660
3661 while (!feof (fd))
3662 {
3663 load_segment (wl_data, fd);
3664
3665 comp += wl_data->cnt;
3666
3667 u32 i = 0;
3668
3669 while (i < wl_data->cnt)
3670 {
3671 u32 len;
3672 u32 off;
3673
3674 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3675
3676 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3677 {
3678 char rule_buf_out[BLOCK_SIZE] = { 0 };
3679
3680 int rule_len_out = -1;
3681
3682 if (len < BLOCK_SIZE)
3683 {
3684 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3685 }
3686
3687 if (rule_len_out < 0)
3688 {
3689 len = PW_MAX1;
3690 }
3691 else
3692 {
3693 len = rule_len_out;
3694 }
3695 }
3696
3697 if (len < PW_MAX1)
3698 {
3699 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3700 {
3701 cnt += data.kernel_rules_cnt;
3702 }
3703 else if (data.attack_kern == ATTACK_KERN_COMBI)
3704 {
3705 cnt += data.combs_cnt;
3706 }
3707
3708 d.cnt++;
3709 }
3710
3711 i += off;
3712
3713 cnt2++;
3714 }
3715
3716 time (&now);
3717
3718 if ((now - prev) == 0) continue;
3719
3720 float percent = (float) comp / (float) d.stat.st_size;
3721
3722 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);
3723
3724 time (&prev);
3725 }
3726
3727 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);
3728 if (data.quiet == 0) log_info ("");
3729
3730 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3731
3732 hc_signal (sigHandler_default);
3733
3734 return (cnt);
3735 }
3736
3737 static void *thread_monitor (void *p)
3738 {
3739 uint runtime_check = 0;
3740 uint remove_check = 0;
3741 uint status_check = 0;
3742 uint restore_check = 0;
3743
3744 uint restore_left = data.restore_timer;
3745 uint remove_left = data.remove_timer;
3746 uint status_left = data.status_timer;
3747
3748 #ifdef HAVE_HWMON
3749 uint hwmon_check = 0;
3750
3751 // these variables are mainly used for fan control (AMD only)
3752
3753 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3754
3755 // temperature controller "loopback" values
3756
3757 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3758 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3759
3760 #ifdef HAVE_ADL
3761 int temp_threshold = 1; // degrees celcius
3762
3763 int fan_speed_min = 15; // in percentage
3764 int fan_speed_max = 100;
3765 #endif // HAVE_ADL
3766
3767 time_t last_temp_check_time;
3768 #endif // HAVE_HWMON
3769
3770 uint sleep_time = 1;
3771
3772 if (data.runtime)
3773 {
3774 runtime_check = 1;
3775 }
3776
3777 if (data.restore_timer)
3778 {
3779 restore_check = 1;
3780 }
3781
3782 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3783 {
3784 remove_check = 1;
3785 }
3786
3787 if (data.status == 1)
3788 {
3789 status_check = 1;
3790 }
3791
3792 #ifdef HAVE_HWMON
3793 if (data.gpu_temp_disable == 0)
3794 {
3795 time (&last_temp_check_time);
3796
3797 hwmon_check = 1;
3798 }
3799 #endif
3800
3801 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3802 {
3803 #ifdef HAVE_HWMON
3804 if (hwmon_check == 0)
3805 #endif
3806 return (p);
3807 }
3808
3809 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3810 {
3811 hc_sleep (sleep_time);
3812
3813 if (data.devices_status != STATUS_RUNNING) continue;
3814
3815 #ifdef HAVE_HWMON
3816 if (hwmon_check == 1)
3817 {
3818 hc_thread_mutex_lock (mux_adl);
3819
3820 time_t temp_check_time;
3821
3822 time (&temp_check_time);
3823
3824 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3825
3826 if (Ta == 0) Ta = 1;
3827
3828 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3829 {
3830 hc_device_param_t *device_param = &data.devices_param[device_id];
3831
3832 if (device_param->skipped) continue;
3833
3834 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3835
3836 const int temperature = hm_get_temperature_with_device_id (device_id);
3837
3838 if (temperature > (int) data.gpu_temp_abort)
3839 {
3840 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3841
3842 if (data.devices_status != STATUS_QUIT) myabort ();
3843
3844 break;
3845 }
3846
3847 #ifdef HAVE_ADL
3848 const int gpu_temp_retain = data.gpu_temp_retain;
3849
3850 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3851 {
3852 if (data.hm_device[device_id].fan_supported == 1)
3853 {
3854 int temp_cur = temperature;
3855
3856 int temp_diff_new = gpu_temp_retain - temp_cur;
3857
3858 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3859
3860 // calculate Ta value (time difference in seconds between the last check and this check)
3861
3862 last_temp_check_time = temp_check_time;
3863
3864 float Kp = 1.8;
3865 float Ki = 0.005;
3866 float Kd = 6;
3867
3868 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3869
3870 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);
3871
3872 if (abs (fan_diff_required) >= temp_threshold)
3873 {
3874 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3875
3876 int fan_speed_level = fan_speed_cur;
3877
3878 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3879
3880 int fan_speed_new = fan_speed_level - fan_diff_required;
3881
3882 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3883 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3884
3885 if (fan_speed_new != fan_speed_cur)
3886 {
3887 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3888 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3889
3890 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3891 {
3892 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3893
3894 fan_speed_chgd[device_id] = 1;
3895 }
3896
3897 temp_diff_old[device_id] = temp_diff_new;
3898 }
3899 }
3900 }
3901 }
3902 #endif // HAVE_ADL
3903 }
3904
3905 hc_thread_mutex_unlock (mux_adl);
3906 }
3907 #endif // HAVE_HWMON
3908
3909 if (restore_check == 1)
3910 {
3911 restore_left--;
3912
3913 if (restore_left == 0)
3914 {
3915 if (data.restore_disable == 0) cycle_restore ();
3916
3917 restore_left = data.restore_timer;
3918 }
3919 }
3920
3921 if ((runtime_check == 1) && (data.runtime_start > 0))
3922 {
3923 time_t runtime_cur;
3924
3925 time (&runtime_cur);
3926
3927 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3928
3929 if (runtime_left <= 0)
3930 {
3931 if (data.benchmark == 0)
3932 {
3933 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3934 }
3935
3936 if (data.devices_status != STATUS_QUIT) myabort ();
3937 }
3938 }
3939
3940 if (remove_check == 1)
3941 {
3942 remove_left--;
3943
3944 if (remove_left == 0)
3945 {
3946 if (data.digests_saved != data.digests_done)
3947 {
3948 data.digests_saved = data.digests_done;
3949
3950 save_hash ();
3951 }
3952
3953 remove_left = data.remove_timer;
3954 }
3955 }
3956
3957 if (status_check == 1)
3958 {
3959 status_left--;
3960
3961 if (status_left == 0)
3962 {
3963 hc_thread_mutex_lock (mux_display);
3964
3965 if (data.quiet == 0) clear_prompt ();
3966
3967 if (data.quiet == 0) log_info ("");
3968
3969 status_display ();
3970
3971 if (data.quiet == 0) log_info ("");
3972
3973 hc_thread_mutex_unlock (mux_display);
3974
3975 status_left = data.status_timer;
3976 }
3977 }
3978 }
3979
3980 #ifdef HAVE_HWMON
3981 myfree (fan_speed_chgd);
3982
3983 myfree (temp_diff_old);
3984 myfree (temp_diff_sum);
3985 #endif
3986
3987 p = NULL;
3988
3989 return (p);
3990 }
3991
3992 static void *thread_outfile_remove (void *p)
3993 {
3994 // some hash-dependent constants
3995 char *outfile_dir = data.outfile_check_directory;
3996 uint dgst_size = data.dgst_size;
3997 uint isSalted = data.isSalted;
3998 uint esalt_size = data.esalt_size;
3999 uint hash_mode = data.hash_mode;
4000
4001 uint outfile_check_timer = data.outfile_check_timer;
4002
4003 char separator = data.separator;
4004
4005 // some hash-dependent functions
4006 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4007 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4008
4009 // buffers
4010 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4011
4012 hash_buf.digest = mymalloc (dgst_size);
4013
4014 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4015
4016 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4017
4018 uint digest_buf[64] = { 0 };
4019
4020 outfile_data_t *out_info = NULL;
4021
4022 char **out_files = NULL;
4023
4024 time_t folder_mtime = 0;
4025
4026 int out_cnt = 0;
4027
4028 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4029
4030 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4031 {
4032 hc_sleep (1);
4033
4034 if (data.devices_status != STATUS_RUNNING) continue;
4035
4036 check_left--;
4037
4038 if (check_left == 0)
4039 {
4040 struct stat outfile_check_stat;
4041
4042 if (stat (outfile_dir, &outfile_check_stat) == 0)
4043 {
4044 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4045
4046 if (is_dir == 1)
4047 {
4048 if (outfile_check_stat.st_mtime > folder_mtime)
4049 {
4050 char **out_files_new = scan_directory (outfile_dir);
4051
4052 int out_cnt_new = count_dictionaries (out_files_new);
4053
4054 outfile_data_t *out_info_new = NULL;
4055
4056 if (out_cnt_new > 0)
4057 {
4058 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4059
4060 for (int i = 0; i < out_cnt_new; i++)
4061 {
4062 out_info_new[i].file_name = out_files_new[i];
4063
4064 // check if there are files that we have seen/checked before (and not changed)
4065
4066 for (int j = 0; j < out_cnt; j++)
4067 {
4068 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4069 {
4070 struct stat outfile_stat;
4071
4072 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4073 {
4074 if (outfile_stat.st_ctime == out_info[j].ctime)
4075 {
4076 out_info_new[i].ctime = out_info[j].ctime;
4077 out_info_new[i].seek = out_info[j].seek;
4078 }
4079 }
4080 }
4081 }
4082 }
4083 }
4084
4085 local_free (out_info);
4086 local_free (out_files);
4087
4088 out_files = out_files_new;
4089 out_cnt = out_cnt_new;
4090 out_info = out_info_new;
4091
4092 folder_mtime = outfile_check_stat.st_mtime;
4093 }
4094
4095 for (int j = 0; j < out_cnt; j++)
4096 {
4097 FILE *fp = fopen (out_info[j].file_name, "rb");
4098
4099 if (fp != NULL)
4100 {
4101 //hc_thread_mutex_lock (mux_display);
4102
4103 #ifdef _POSIX
4104 struct stat outfile_stat;
4105
4106 fstat (fileno (fp), &outfile_stat);
4107 #endif
4108
4109 #ifdef _WIN
4110 struct stat64 outfile_stat;
4111
4112 _fstat64 (fileno (fp), &outfile_stat);
4113 #endif
4114
4115 if (outfile_stat.st_ctime > out_info[j].ctime)
4116 {
4117 out_info[j].ctime = outfile_stat.st_ctime;
4118 out_info[j].seek = 0;
4119 }
4120
4121 fseek (fp, out_info[j].seek, SEEK_SET);
4122
4123 while (!feof (fp))
4124 {
4125 char line_buf[BUFSIZ] = { 0 };
4126
4127 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
4128
4129 if (ptr == NULL) break;
4130
4131 int line_len = strlen (line_buf);
4132
4133 if (line_len <= 0) continue;
4134
4135 int iter = MAX_CUT_TRIES;
4136
4137 for (uint i = line_len - 1; i && iter; i--, line_len--)
4138 {
4139 if (line_buf[i] != separator) continue;
4140
4141 int parser_status = PARSER_OK;
4142
4143 if ((hash_mode != 2500) && (hash_mode != 6800))
4144 {
4145 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4146 }
4147
4148 uint found = 0;
4149
4150 if (parser_status == PARSER_OK)
4151 {
4152 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4153 {
4154 if (data.salts_shown[salt_pos] == 1) continue;
4155
4156 salt_t *salt_buf = &data.salts_buf[salt_pos];
4157
4158 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4159 {
4160 uint idx = salt_buf->digests_offset + digest_pos;
4161
4162 if (data.digests_shown[idx] == 1) continue;
4163
4164 uint cracked = 0;
4165
4166 if (hash_mode == 6800)
4167 {
4168 if (i == salt_buf->salt_len)
4169 {
4170 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4171 }
4172 }
4173 else if (hash_mode == 2500)
4174 {
4175 // BSSID : MAC1 : MAC2 (:plain)
4176 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4177 {
4178 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4179
4180 if (!cracked) continue;
4181
4182 // now compare MAC1 and MAC2 too, since we have this additional info
4183 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4184 char *mac2_pos = mac1_pos + 12 + 1;
4185
4186 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4187 wpa_t *wpa = &wpas[salt_pos];
4188
4189 uint pke[25] = { 0 };
4190
4191 char *pke_ptr = (char *) pke;
4192
4193 for (uint i = 0; i < 25; i++)
4194 {
4195 pke[i] = byte_swap_32 (wpa->pke[i]);
4196 }
4197
4198 u8 mac1[6] = { 0 };
4199 u8 mac2[6] = { 0 };
4200
4201 memcpy (mac1, pke_ptr + 23, 6);
4202 memcpy (mac2, pke_ptr + 29, 6);
4203
4204 // compare hex string(s) vs binary MAC address(es)
4205
4206 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4207 {
4208 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4209 {
4210 cracked = 0;
4211 break;
4212 }
4213 }
4214
4215 // early skip ;)
4216 if (!cracked) continue;
4217
4218 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4219 {
4220 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4221 {
4222 cracked = 0;
4223 break;
4224 }
4225 }
4226 }
4227 }
4228 else
4229 {
4230 char *digests_buf_ptr = (char *) data.digests_buf;
4231
4232 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4233
4234 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4235 }
4236
4237 if (cracked == 1)
4238 {
4239 found = 1;
4240
4241 data.digests_shown[idx] = 1;
4242
4243 data.digests_done++;
4244
4245 salt_buf->digests_done++;
4246
4247 if (salt_buf->digests_done == salt_buf->digests_cnt)
4248 {
4249 data.salts_shown[salt_pos] = 1;
4250
4251 data.salts_done++;
4252
4253 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4254 }
4255 }
4256 }
4257
4258 if (data.devices_status == STATUS_CRACKED) break;
4259 }
4260 }
4261
4262 if (found) break;
4263
4264 if (data.devices_status == STATUS_CRACKED) break;
4265
4266 iter--;
4267 }
4268
4269 if (data.devices_status == STATUS_CRACKED) break;
4270 }
4271
4272 out_info[j].seek = ftell (fp);
4273
4274 //hc_thread_mutex_unlock (mux_display);
4275
4276 fclose (fp);
4277 }
4278 }
4279 }
4280 }
4281
4282 check_left = outfile_check_timer;
4283 }
4284 }
4285
4286 if (esalt_size) local_free (hash_buf.esalt);
4287
4288 if (isSalted) local_free (hash_buf.salt);
4289
4290 local_free (hash_buf.digest);
4291
4292 local_free (out_info);
4293
4294 local_free (out_files);
4295
4296 p = NULL;
4297
4298 return (p);
4299 }
4300
4301 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4302 {
4303 if (device_param->pws_cnt < device_param->kernel_power)
4304 {
4305 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4306
4307 u8 *ptr = (u8 *) pw->i;
4308
4309 memcpy (ptr, pw_buf, pw_len);
4310
4311 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4312
4313 pw->pw_len = pw_len;
4314
4315 device_param->pws_cnt++;
4316 }
4317 else
4318 {
4319 fprintf (stderr, "BUG pw_add()!!\n");
4320
4321 return;
4322 }
4323 }
4324
4325 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4326 {
4327 hc_thread_mutex_lock (mux_dispatcher);
4328
4329 const u64 words_cur = data.words_cur;
4330 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4331
4332 device_param->words_off = words_cur;
4333
4334 const u64 words_left = words_base - words_cur;
4335
4336 if (allow_div)
4337 {
4338 if (data.kernel_power_all > words_left)
4339 {
4340 if (data.kernel_power_div == 0)
4341 {
4342 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4343 }
4344 }
4345
4346 if (data.kernel_power_div)
4347 {
4348 if (device_param->kernel_power == device_param->kernel_power_user)
4349 {
4350 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4351
4352 if (kernel_power_new < device_param->kernel_power)
4353 {
4354 device_param->kernel_power = kernel_power_new;
4355 }
4356 }
4357 }
4358 }
4359
4360 const uint kernel_power = device_param->kernel_power;
4361
4362 uint work = MIN (words_left, kernel_power);
4363
4364 work = MIN (work, max);
4365
4366 data.words_cur += work;
4367
4368 hc_thread_mutex_unlock (mux_dispatcher);
4369
4370 return work;
4371 }
4372
4373 static void *thread_calc_stdin (void *p)
4374 {
4375 hc_device_param_t *device_param = (hc_device_param_t *) p;
4376
4377 if (device_param->skipped) return NULL;
4378
4379 autotune (device_param);
4380
4381 const uint attack_kern = data.attack_kern;
4382
4383 const uint kernel_power = device_param->kernel_power;
4384
4385 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4386 {
4387 hc_thread_mutex_lock (mux_dispatcher);
4388
4389 if (feof (stdin) != 0)
4390 {
4391 hc_thread_mutex_unlock (mux_dispatcher);
4392
4393 break;
4394 }
4395
4396 uint words_cur = 0;
4397
4398 while (words_cur < kernel_power)
4399 {
4400 char buf[BUFSIZ] = { 0 };
4401
4402 char *line_buf = fgets (buf, sizeof (buf), stdin);
4403
4404 if (line_buf == NULL) break;
4405
4406 uint line_len = in_superchop (line_buf);
4407
4408 line_len = convert_from_hex (line_buf, line_len);
4409
4410 // post-process rule engine
4411
4412 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4413 {
4414 char rule_buf_out[BLOCK_SIZE] = { 0 };
4415
4416 int rule_len_out = -1;
4417
4418 if (line_len < BLOCK_SIZE)
4419 {
4420 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4421 }
4422
4423 if (rule_len_out < 0) continue;
4424
4425 line_buf = rule_buf_out;
4426 line_len = rule_len_out;
4427 }
4428
4429 if (line_len > PW_MAX)
4430 {
4431 continue;
4432 }
4433
4434 if (attack_kern == ATTACK_KERN_STRAIGHT)
4435 {
4436 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4437 {
4438 hc_thread_mutex_lock (mux_counter);
4439
4440 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4441 {
4442 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4443 }
4444
4445 hc_thread_mutex_unlock (mux_counter);
4446
4447 continue;
4448 }
4449 }
4450 else if (attack_kern == ATTACK_KERN_COMBI)
4451 {
4452 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4453 // since we still need to combine the plains
4454
4455 if (line_len > data.pw_max)
4456 {
4457 hc_thread_mutex_lock (mux_counter);
4458
4459 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4460 {
4461 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4462 }
4463
4464 hc_thread_mutex_unlock (mux_counter);
4465
4466 continue;
4467 }
4468 }
4469
4470 pw_add (device_param, (u8 *) line_buf, line_len);
4471
4472 words_cur++;
4473
4474 if (data.devices_status == STATUS_CRACKED) break;
4475 if (data.devices_status == STATUS_ABORTED) break;
4476 if (data.devices_status == STATUS_QUIT) break;
4477 if (data.devices_status == STATUS_BYPASS) break;
4478 }
4479
4480 hc_thread_mutex_unlock (mux_dispatcher);
4481
4482 if (data.devices_status == STATUS_CRACKED) break;
4483 if (data.devices_status == STATUS_ABORTED) break;
4484 if (data.devices_status == STATUS_QUIT) break;
4485 if (data.devices_status == STATUS_BYPASS) break;
4486
4487 // flush
4488
4489 const uint pws_cnt = device_param->pws_cnt;
4490
4491 if (pws_cnt)
4492 {
4493 run_copy (device_param, pws_cnt);
4494
4495 run_cracker (device_param, pws_cnt);
4496
4497 device_param->pws_cnt = 0;
4498
4499 if (attack_kern == ATTACK_KERN_STRAIGHT)
4500 {
4501 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4502 }
4503 else if (attack_kern == ATTACK_KERN_COMBI)
4504 {
4505 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4506 }
4507 }
4508 }
4509
4510 device_param->kernel_accel = 0;
4511 device_param->kernel_loops = 0;
4512
4513 return NULL;
4514 }
4515
4516 static void *thread_calc (void *p)
4517 {
4518 hc_device_param_t *device_param = (hc_device_param_t *) p;
4519
4520 if (device_param->skipped) return NULL;
4521
4522 autotune (device_param);
4523
4524 const uint attack_mode = data.attack_mode;
4525 const uint attack_kern = data.attack_kern;
4526
4527 if (attack_mode == ATTACK_MODE_BF)
4528 {
4529 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4530 {
4531 const uint work = get_work (device_param, -1, true);
4532
4533 if (work == 0) break;
4534
4535 const u64 words_off = device_param->words_off;
4536 const u64 words_fin = words_off + work;
4537
4538 const uint pws_cnt = work;
4539
4540 device_param->pws_cnt = pws_cnt;
4541
4542 if (pws_cnt)
4543 {
4544 run_copy (device_param, pws_cnt);
4545
4546 run_cracker (device_param, pws_cnt);
4547
4548 device_param->pws_cnt = 0;
4549
4550 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4551 }
4552
4553 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4554
4555 if (data.devices_status == STATUS_CRACKED) break;
4556 if (data.devices_status == STATUS_ABORTED) break;
4557 if (data.devices_status == STATUS_QUIT) break;
4558 if (data.devices_status == STATUS_BYPASS) break;
4559
4560 if (data.benchmark == 1) break;
4561
4562 device_param->words_done = words_fin;
4563 }
4564 }
4565 else
4566 {
4567 const uint segment_size = data.segment_size;
4568
4569 char *dictfile = data.dictfile;
4570
4571 if (attack_mode == ATTACK_MODE_COMBI)
4572 {
4573 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4574 {
4575 dictfile = data.dictfile2;
4576 }
4577 }
4578
4579 FILE *fd = fopen (dictfile, "rb");
4580
4581 if (fd == NULL)
4582 {
4583 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4584
4585 return NULL;
4586 }
4587
4588 if (attack_mode == ATTACK_MODE_COMBI)
4589 {
4590 const uint combs_mode = data.combs_mode;
4591
4592 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4593 {
4594 const char *dictfilec = data.dictfile2;
4595
4596 FILE *combs_fp = fopen (dictfilec, "rb");
4597
4598 if (combs_fp == NULL)
4599 {
4600 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4601
4602 fclose (fd);
4603
4604 return NULL;
4605 }
4606
4607 device_param->combs_fp = combs_fp;
4608 }
4609 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4610 {
4611 const char *dictfilec = data.dictfile;
4612
4613 FILE *combs_fp = fopen (dictfilec, "rb");
4614
4615 if (combs_fp == NULL)
4616 {
4617 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4618
4619 fclose (fd);
4620
4621 return NULL;
4622 }
4623
4624 device_param->combs_fp = combs_fp;
4625 }
4626 }
4627
4628 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4629
4630 wl_data->buf = (char *) mymalloc (segment_size);
4631 wl_data->avail = segment_size;
4632 wl_data->incr = segment_size;
4633 wl_data->cnt = 0;
4634 wl_data->pos = 0;
4635
4636 u64 words_cur = 0;
4637
4638 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4639 {
4640 u64 words_off = 0;
4641 u64 words_fin = 0;
4642
4643 bool allow_div = true;
4644
4645 u64 max = -1;
4646
4647 while (max)
4648 {
4649 const uint work = get_work (device_param, max, allow_div);
4650
4651 allow_div = false;
4652
4653 if (work == 0) break;
4654
4655 words_off = device_param->words_off;
4656 words_fin = words_off + work;
4657
4658 char *line_buf;
4659 uint line_len;
4660
4661 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4662
4663 max = 0;
4664
4665 for ( ; words_cur < words_fin; words_cur++)
4666 {
4667 get_next_word (wl_data, fd, &line_buf, &line_len);
4668
4669 line_len = convert_from_hex (line_buf, line_len);
4670
4671 // post-process rule engine
4672
4673 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4674 {
4675 char rule_buf_out[BLOCK_SIZE] = { 0 };
4676
4677 int rule_len_out = -1;
4678
4679 if (line_len < BLOCK_SIZE)
4680 {
4681 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4682 }
4683
4684 if (rule_len_out < 0) continue;
4685
4686 line_buf = rule_buf_out;
4687 line_len = rule_len_out;
4688 }
4689
4690 if (attack_kern == ATTACK_KERN_STRAIGHT)
4691 {
4692 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4693 {
4694 max++;
4695
4696 hc_thread_mutex_lock (mux_counter);
4697
4698 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4699 {
4700 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4701 }
4702
4703 hc_thread_mutex_unlock (mux_counter);
4704
4705 continue;
4706 }
4707 }
4708 else if (attack_kern == ATTACK_KERN_COMBI)
4709 {
4710 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4711 // since we still need to combine the plains
4712
4713 if (line_len > data.pw_max)
4714 {
4715 max++;
4716
4717 hc_thread_mutex_lock (mux_counter);
4718
4719 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4720 {
4721 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4722 }
4723
4724 hc_thread_mutex_unlock (mux_counter);
4725
4726 continue;
4727 }
4728 }
4729
4730 pw_add (device_param, (u8 *) line_buf, line_len);
4731
4732 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4733
4734 if (data.devices_status == STATUS_CRACKED) break;
4735 if (data.devices_status == STATUS_ABORTED) break;
4736 if (data.devices_status == STATUS_QUIT) break;
4737 if (data.devices_status == STATUS_BYPASS) break;
4738 }
4739
4740 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4741
4742 if (data.devices_status == STATUS_CRACKED) break;
4743 if (data.devices_status == STATUS_ABORTED) break;
4744 if (data.devices_status == STATUS_QUIT) break;
4745 if (data.devices_status == STATUS_BYPASS) break;
4746 }
4747
4748 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4749
4750 if (data.devices_status == STATUS_CRACKED) break;
4751 if (data.devices_status == STATUS_ABORTED) break;
4752 if (data.devices_status == STATUS_QUIT) break;
4753 if (data.devices_status == STATUS_BYPASS) break;
4754
4755 //
4756 // flush
4757 //
4758
4759 const uint pws_cnt = device_param->pws_cnt;
4760
4761 if (pws_cnt)
4762 {
4763 run_copy (device_param, pws_cnt);
4764
4765 run_cracker (device_param, pws_cnt);
4766
4767 device_param->pws_cnt = 0;
4768
4769 if (attack_kern == ATTACK_KERN_STRAIGHT)
4770 {
4771 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4772 }
4773 else if (attack_kern == ATTACK_KERN_COMBI)
4774 {
4775 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4776 }
4777 }
4778
4779 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4780
4781 if (data.devices_status == STATUS_CRACKED) break;
4782 if (data.devices_status == STATUS_ABORTED) break;
4783 if (data.devices_status == STATUS_QUIT) break;
4784 if (data.devices_status == STATUS_BYPASS) break;
4785
4786 if (words_fin == 0) break;
4787
4788 device_param->words_done = words_fin;
4789 }
4790
4791 if (attack_mode == ATTACK_MODE_COMBI)
4792 {
4793 fclose (device_param->combs_fp);
4794 }
4795
4796 free (wl_data->buf);
4797 free (wl_data);
4798
4799 fclose (fd);
4800 }
4801
4802 device_param->kernel_accel = 0;
4803 device_param->kernel_loops = 0;
4804
4805 return NULL;
4806 }
4807
4808 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4809 {
4810 if (!device_param)
4811 {
4812 log_error ("ERROR: %s : Invalid argument", __func__);
4813
4814 exit (-1);
4815 }
4816
4817 salt_t *salt_buf = &data.salts_buf[salt_pos];
4818
4819 device_param->kernel_params_buf32[24] = salt_pos;
4820 device_param->kernel_params_buf32[27] = 1;
4821 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4822 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4823 device_param->kernel_params_buf32[30] = 0;
4824 device_param->kernel_params_buf32[31] = 1;
4825
4826 char *dictfile_old = data.dictfile;
4827
4828 const char *weak_hash_check = "weak-hash-check";
4829
4830 data.dictfile = (char *) weak_hash_check;
4831
4832 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4833
4834 data.kernel_rules_buf[0].cmds[0] = 0;
4835
4836 /**
4837 * run the kernel
4838 */
4839
4840 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4841 {
4842 run_kernel (KERN_RUN_1, device_param, 1, false);
4843 }
4844 else
4845 {
4846 run_kernel (KERN_RUN_1, device_param, 1, false);
4847
4848 uint loop_step = 16;
4849
4850 const uint iter = salt_buf->salt_iter;
4851
4852 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4853 {
4854 uint loop_left = iter - loop_pos;
4855
4856 loop_left = MIN (loop_left, loop_step);
4857
4858 device_param->kernel_params_buf32[25] = loop_pos;
4859 device_param->kernel_params_buf32[26] = loop_left;
4860
4861 run_kernel (KERN_RUN_2, device_param, 1, false);
4862 }
4863
4864 run_kernel (KERN_RUN_3, device_param, 1, false);
4865 }
4866
4867 /**
4868 * result
4869 */
4870
4871 check_cracked (device_param, salt_pos);
4872
4873 /**
4874 * cleanup
4875 */
4876
4877 device_param->kernel_params_buf32[24] = 0;
4878 device_param->kernel_params_buf32[25] = 0;
4879 device_param->kernel_params_buf32[26] = 0;
4880 device_param->kernel_params_buf32[27] = 0;
4881 device_param->kernel_params_buf32[28] = 0;
4882 device_param->kernel_params_buf32[29] = 0;
4883 device_param->kernel_params_buf32[30] = 0;
4884 device_param->kernel_params_buf32[31] = 0;
4885
4886 data.dictfile = dictfile_old;
4887
4888 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4889 }
4890
4891 // hlfmt hashcat
4892
4893 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4894 {
4895 if (data.username == 0)
4896 {
4897 *hashbuf_pos = line_buf;
4898 *hashbuf_len = line_len;
4899 }
4900 else
4901 {
4902 char *pos = line_buf;
4903 int len = line_len;
4904
4905 for (int i = 0; i < line_len; i++, pos++, len--)
4906 {
4907 if (line_buf[i] == data.separator)
4908 {
4909 pos++;
4910
4911 len--;
4912
4913 break;
4914 }
4915 }
4916
4917 *hashbuf_pos = pos;
4918 *hashbuf_len = len;
4919 }
4920 }
4921
4922 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4923 {
4924 char *pos = NULL;
4925 int len = 0;
4926
4927 int sep_cnt = 0;
4928
4929 for (int i = 0; i < line_len; i++)
4930 {
4931 if (line_buf[i] == data.separator)
4932 {
4933 sep_cnt++;
4934
4935 continue;
4936 }
4937
4938 if (sep_cnt == 0)
4939 {
4940 if (pos == NULL) pos = line_buf + i;
4941
4942 len++;
4943 }
4944 }
4945
4946 *userbuf_pos = pos;
4947 *userbuf_len = len;
4948 }
4949
4950 // hlfmt pwdump
4951
4952 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4953 {
4954 int sep_cnt = 0;
4955
4956 int sep2_len = 0;
4957 int sep3_len = 0;
4958
4959 for (int i = 0; i < line_len; i++)
4960 {
4961 if (line_buf[i] == ':')
4962 {
4963 sep_cnt++;
4964
4965 continue;
4966 }
4967
4968 if (sep_cnt == 2) sep2_len++;
4969 if (sep_cnt == 3) sep3_len++;
4970 }
4971
4972 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4973
4974 return 0;
4975 }
4976
4977 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4978 {
4979 char *pos = NULL;
4980 int len = 0;
4981
4982 int sep_cnt = 0;
4983
4984 for (int i = 0; i < line_len; i++)
4985 {
4986 if (line_buf[i] == ':')
4987 {
4988 sep_cnt++;
4989
4990 continue;
4991 }
4992
4993 if (data.hash_mode == 1000)
4994 {
4995 if (sep_cnt == 3)
4996 {
4997 if (pos == NULL) pos = line_buf + i;
4998
4999 len++;
5000 }
5001 }
5002 else if (data.hash_mode == 3000)
5003 {
5004 if (sep_cnt == 2)
5005 {
5006 if (pos == NULL) pos = line_buf + i;
5007
5008 len++;
5009 }
5010 }
5011 }
5012
5013 *hashbuf_pos = pos;
5014 *hashbuf_len = len;
5015 }
5016
5017 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5018 {
5019 char *pos = NULL;
5020 int len = 0;
5021
5022 int sep_cnt = 0;
5023
5024 for (int i = 0; i < line_len; i++)
5025 {
5026 if (line_buf[i] == ':')
5027 {
5028 sep_cnt++;
5029
5030 continue;
5031 }
5032
5033 if (sep_cnt == 0)
5034 {
5035 if (pos == NULL) pos = line_buf + i;
5036
5037 len++;
5038 }
5039 }
5040
5041 *userbuf_pos = pos;
5042 *userbuf_len = len;
5043 }
5044
5045 // hlfmt passwd
5046
5047 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5048 {
5049 int sep_cnt = 0;
5050
5051 char sep5_first = 0;
5052 char sep6_first = 0;
5053
5054 for (int i = 0; i < line_len; i++)
5055 {
5056 if (line_buf[i] == ':')
5057 {
5058 sep_cnt++;
5059
5060 continue;
5061 }
5062
5063 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5064 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5065 }
5066
5067 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5068
5069 return 0;
5070 }
5071
5072 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5073 {
5074 char *pos = NULL;
5075 int len = 0;
5076
5077 int sep_cnt = 0;
5078
5079 for (int i = 0; i < line_len; i++)
5080 {
5081 if (line_buf[i] == ':')
5082 {
5083 sep_cnt++;
5084
5085 continue;
5086 }
5087
5088 if (sep_cnt == 1)
5089 {
5090 if (pos == NULL) pos = line_buf + i;
5091
5092 len++;
5093 }
5094 }
5095
5096 *hashbuf_pos = pos;
5097 *hashbuf_len = len;
5098 }
5099
5100 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5101 {
5102 char *pos = NULL;
5103 int len = 0;
5104
5105 int sep_cnt = 0;
5106
5107 for (int i = 0; i < line_len; i++)
5108 {
5109 if (line_buf[i] == ':')
5110 {
5111 sep_cnt++;
5112
5113 continue;
5114 }
5115
5116 if (sep_cnt == 0)
5117 {
5118 if (pos == NULL) pos = line_buf + i;
5119
5120 len++;
5121 }
5122 }
5123
5124 *userbuf_pos = pos;
5125 *userbuf_len = len;
5126 }
5127
5128 // hlfmt shadow
5129
5130 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5131 {
5132 int sep_cnt = 0;
5133
5134 for (int i = 0; i < line_len; i++)
5135 {
5136 if (line_buf[i] == ':') sep_cnt++;
5137 }
5138
5139 if (sep_cnt == 8) return 1;
5140
5141 return 0;
5142 }
5143
5144 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5145 {
5146 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5147 }
5148
5149 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5150 {
5151 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5152 }
5153
5154 // hlfmt main
5155
5156 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5157 {
5158 switch (hashfile_format)
5159 {
5160 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5161 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5162 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5163 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5164 }
5165 }
5166
5167 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5168 {
5169 switch (hashfile_format)
5170 {
5171 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5172 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5173 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5174 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5175 }
5176 }
5177
5178 static uint hlfmt_detect (FILE *fp, uint max_check)
5179 {
5180 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5181
5182 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5183 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5184
5185 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5186
5187 uint num_check = 0;
5188
5189 while (!feof (fp))
5190 {
5191 char line_buf[BUFSIZ] = { 0 };
5192
5193 int line_len = fgetl (fp, line_buf);
5194
5195 if (line_len == 0) continue;
5196
5197 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5198 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5199 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5200
5201 if (num_check == max_check) break;
5202
5203 num_check++;
5204 }
5205
5206 uint hashlist_format = HLFMT_HASHCAT;
5207
5208 for (int i = 1; i < HLFMTS_CNT; i++)
5209 {
5210 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5211
5212 hashlist_format = i;
5213 }
5214
5215 free (formats_cnt);
5216
5217 return hashlist_format;
5218 }
5219
5220 /**
5221 * some further helper function
5222 */
5223
5224 // wrapper around mymalloc for ADL
5225
5226 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5227 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5228 {
5229 return mymalloc (iSize);
5230 }
5231 #endif
5232
5233 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)
5234 {
5235 u64 collisions = 0;
5236
5237 const uint dgst_pos0 = data.dgst_pos0;
5238 const uint dgst_pos1 = data.dgst_pos1;
5239 const uint dgst_pos2 = data.dgst_pos2;
5240 const uint dgst_pos3 = data.dgst_pos3;
5241
5242 memset (bitmap_a, 0, bitmap_size);
5243 memset (bitmap_b, 0, bitmap_size);
5244 memset (bitmap_c, 0, bitmap_size);
5245 memset (bitmap_d, 0, bitmap_size);
5246
5247 for (uint i = 0; i < digests_cnt; i++)
5248 {
5249 uint *digest_ptr = (uint *) digests_buf_ptr;
5250
5251 digests_buf_ptr += dgst_size;
5252
5253 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5254 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5255 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5256 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5257
5258 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5259 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5260 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5261 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5262
5263 if (bitmap_a[idx0] & val0) collisions++;
5264 if (bitmap_b[idx1] & val1) collisions++;
5265 if (bitmap_c[idx2] & val2) collisions++;
5266 if (bitmap_d[idx3] & val3) collisions++;
5267
5268 bitmap_a[idx0] |= val0;
5269 bitmap_b[idx1] |= val1;
5270 bitmap_c[idx2] |= val2;
5271 bitmap_d[idx3] |= val3;
5272
5273 if (collisions >= collisions_max) return 0x7fffffff;
5274 }
5275
5276 return collisions;
5277 }
5278
5279 /**
5280 * main
5281 */
5282
5283 int main (int argc, char **argv)
5284 {
5285 /**
5286 * To help users a bit
5287 */
5288
5289 char *compute = getenv ("COMPUTE");
5290
5291 if (compute)
5292 {
5293 static char display[100];
5294
5295 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5296
5297 putenv (display);
5298 }
5299 else
5300 {
5301 if (getenv ("DISPLAY") == NULL)
5302 putenv ((char *) "DISPLAY=:0");
5303 }
5304
5305 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5306 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5307
5308 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5309 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5310
5311 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5312 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5313
5314 /**
5315 * Real init
5316 */
5317
5318 memset (&data, 0, sizeof (hc_global_data_t));
5319
5320 time_t proc_start;
5321
5322 time (&proc_start);
5323
5324 data.proc_start = proc_start;
5325
5326 int myargc = argc;
5327 char **myargv = argv;
5328
5329 hc_thread_mutex_init (mux_dispatcher);
5330 hc_thread_mutex_init (mux_counter);
5331 hc_thread_mutex_init (mux_display);
5332 hc_thread_mutex_init (mux_adl);
5333
5334 /**
5335 * commandline parameters
5336 */
5337
5338 uint usage = USAGE;
5339 uint version = VERSION;
5340 uint quiet = QUIET;
5341 uint benchmark = BENCHMARK;
5342 uint benchmark_repeats = BENCHMARK_REPEATS;
5343 uint show = SHOW;
5344 uint left = LEFT;
5345 uint username = USERNAME;
5346 uint remove = REMOVE;
5347 uint remove_timer = REMOVE_TIMER;
5348 u64 skip = SKIP;
5349 u64 limit = LIMIT;
5350 uint keyspace = KEYSPACE;
5351 uint potfile_disable = POTFILE_DISABLE;
5352 uint debug_mode = DEBUG_MODE;
5353 char *debug_file = NULL;
5354 char *induction_dir = NULL;
5355 char *outfile_check_dir = NULL;
5356 uint force = FORCE;
5357 uint runtime = RUNTIME;
5358 uint hash_mode = HASH_MODE;
5359 uint attack_mode = ATTACK_MODE;
5360 uint markov_disable = MARKOV_DISABLE;
5361 uint markov_classic = MARKOV_CLASSIC;
5362 uint markov_threshold = MARKOV_THRESHOLD;
5363 char *markov_hcstat = NULL;
5364 char *outfile = NULL;
5365 uint outfile_format = OUTFILE_FORMAT;
5366 uint outfile_autohex = OUTFILE_AUTOHEX;
5367 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5368 uint restore = RESTORE;
5369 uint restore_timer = RESTORE_TIMER;
5370 uint restore_disable = RESTORE_DISABLE;
5371 uint status = STATUS;
5372 uint status_timer = STATUS_TIMER;
5373 uint status_automat = STATUS_AUTOMAT;
5374 uint loopback = LOOPBACK;
5375 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5376 char *session = NULL;
5377 uint hex_charset = HEX_CHARSET;
5378 uint hex_salt = HEX_SALT;
5379 uint hex_wordlist = HEX_WORDLIST;
5380 uint rp_gen = RP_GEN;
5381 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5382 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5383 uint rp_gen_seed = RP_GEN_SEED;
5384 char *rule_buf_l = (char *) RULE_BUF_L;
5385 char *rule_buf_r = (char *) RULE_BUF_R;
5386 uint increment = INCREMENT;
5387 uint increment_min = INCREMENT_MIN;
5388 uint increment_max = INCREMENT_MAX;
5389 char *cpu_affinity = NULL;
5390 OCL_PTR *ocl = NULL;
5391 char *opencl_devices = NULL;
5392 char *opencl_platforms = NULL;
5393 char *opencl_device_types = NULL;
5394 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5395 char *truecrypt_keyfiles = NULL;
5396 uint workload_profile = WORKLOAD_PROFILE;
5397 uint kernel_accel = KERNEL_ACCEL;
5398 uint kernel_loops = KERNEL_LOOPS;
5399 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5400 #ifdef HAVE_HWMON
5401 uint gpu_temp_abort = GPU_TEMP_ABORT;
5402 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5403 #ifdef HAVE_ADL
5404 uint powertune_enable = POWERTUNE_ENABLE;
5405 #endif
5406 #endif
5407 uint logfile_disable = LOGFILE_DISABLE;
5408 uint segment_size = SEGMENT_SIZE;
5409 uint scrypt_tmto = SCRYPT_TMTO;
5410 char separator = SEPARATOR;
5411 uint bitmap_min = BITMAP_MIN;
5412 uint bitmap_max = BITMAP_MAX;
5413 char *custom_charset_1 = NULL;
5414 char *custom_charset_2 = NULL;
5415 char *custom_charset_3 = NULL;
5416 char *custom_charset_4 = NULL;
5417
5418 #define IDX_HELP 'h'
5419 #define IDX_VERSION 'V'
5420 #define IDX_VERSION_LOWER 'v'
5421 #define IDX_QUIET 0xff02
5422 #define IDX_SHOW 0xff03
5423 #define IDX_LEFT 0xff04
5424 #define IDX_REMOVE 0xff05
5425 #define IDX_REMOVE_TIMER 0xff37
5426 #define IDX_SKIP 's'
5427 #define IDX_LIMIT 'l'
5428 #define IDX_KEYSPACE 0xff35
5429 #define IDX_POTFILE_DISABLE 0xff06
5430 #define IDX_DEBUG_MODE 0xff43
5431 #define IDX_DEBUG_FILE 0xff44
5432 #define IDX_INDUCTION_DIR 0xff46
5433 #define IDX_OUTFILE_CHECK_DIR 0xff47
5434 #define IDX_USERNAME 0xff07
5435 #define IDX_FORCE 0xff08
5436 #define IDX_RUNTIME 0xff09
5437 #define IDX_BENCHMARK 'b'
5438 #define IDX_BENCHMARK_REPEATS 0xff78
5439 #define IDX_HASH_MODE 'm'
5440 #define IDX_ATTACK_MODE 'a'
5441 #define IDX_RP_FILE 'r'
5442 #define IDX_RP_GEN 'g'
5443 #define IDX_RP_GEN_FUNC_MIN 0xff10
5444 #define IDX_RP_GEN_FUNC_MAX 0xff11
5445 #define IDX_RP_GEN_SEED 0xff34
5446 #define IDX_RULE_BUF_L 'j'
5447 #define IDX_RULE_BUF_R 'k'
5448 #define IDX_INCREMENT 'i'
5449 #define IDX_INCREMENT_MIN 0xff12
5450 #define IDX_INCREMENT_MAX 0xff13
5451 #define IDX_OUTFILE 'o'
5452 #define IDX_OUTFILE_FORMAT 0xff14
5453 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5454 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5455 #define IDX_RESTORE 0xff15
5456 #define IDX_RESTORE_DISABLE 0xff27
5457 #define IDX_STATUS 0xff17
5458 #define IDX_STATUS_TIMER 0xff18
5459 #define IDX_STATUS_AUTOMAT 0xff50
5460 #define IDX_LOOPBACK 0xff38
5461 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5462 #define IDX_SESSION 0xff19
5463 #define IDX_HEX_CHARSET 0xff20
5464 #define IDX_HEX_SALT 0xff21
5465 #define IDX_HEX_WORDLIST 0xff40
5466 #define IDX_MARKOV_DISABLE 0xff22
5467 #define IDX_MARKOV_CLASSIC 0xff23
5468 #define IDX_MARKOV_THRESHOLD 't'
5469 #define IDX_MARKOV_HCSTAT 0xff24
5470 #define IDX_CPU_AFFINITY 0xff25
5471 #define IDX_OPENCL_DEVICES 'd'
5472 #define IDX_OPENCL_PLATFORMS 0xff72
5473 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5474 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5475 #define IDX_WORKLOAD_PROFILE 'w'
5476 #define IDX_KERNEL_ACCEL 'n'
5477 #define IDX_KERNEL_LOOPS 'u'
5478 #define IDX_GPU_TEMP_DISABLE 0xff29
5479 #define IDX_GPU_TEMP_ABORT 0xff30
5480 #define IDX_GPU_TEMP_RETAIN 0xff31
5481 #define IDX_POWERTUNE_ENABLE 0xff41
5482 #define IDX_LOGFILE_DISABLE 0xff51
5483 #define IDX_TRUECRYPT_KEYFILES 0xff52
5484 #define IDX_SCRYPT_TMTO 0xff61
5485 #define IDX_SEGMENT_SIZE 'c'
5486 #define IDX_SEPARATOR 'p'
5487 #define IDX_BITMAP_MIN 0xff70
5488 #define IDX_BITMAP_MAX 0xff71
5489 #define IDX_CUSTOM_CHARSET_1 '1'
5490 #define IDX_CUSTOM_CHARSET_2 '2'
5491 #define IDX_CUSTOM_CHARSET_3 '3'
5492 #define IDX_CUSTOM_CHARSET_4 '4'
5493
5494 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5495
5496 struct option long_options[] =
5497 {
5498 {"help", no_argument, 0, IDX_HELP},
5499 {"version", no_argument, 0, IDX_VERSION},
5500 {"quiet", no_argument, 0, IDX_QUIET},
5501 {"show", no_argument, 0, IDX_SHOW},
5502 {"left", no_argument, 0, IDX_LEFT},
5503 {"username", no_argument, 0, IDX_USERNAME},
5504 {"remove", no_argument, 0, IDX_REMOVE},
5505 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5506 {"skip", required_argument, 0, IDX_SKIP},
5507 {"limit", required_argument, 0, IDX_LIMIT},
5508 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5509 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5510 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5511 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5512 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5513 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5514 {"force", no_argument, 0, IDX_FORCE},
5515 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5516 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5517 {"restore", no_argument, 0, IDX_RESTORE},
5518 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5519 {"status", no_argument, 0, IDX_STATUS},
5520 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5521 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5522 {"loopback", no_argument, 0, IDX_LOOPBACK},
5523 {"weak-hash-threshold",
5524 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5525 {"session", required_argument, 0, IDX_SESSION},
5526 {"runtime", required_argument, 0, IDX_RUNTIME},
5527 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5528 {"generate-rules-func-min",
5529 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5530 {"generate-rules-func-max",
5531 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5532 {"generate-rules-seed",
5533 required_argument, 0, IDX_RP_GEN_SEED},
5534 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5535 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5536 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5537 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5538 {"rules-file", required_argument, 0, IDX_RP_FILE},
5539 {"outfile", required_argument, 0, IDX_OUTFILE},
5540 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5541 {"outfile-autohex-disable",
5542 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5543 {"outfile-check-timer",
5544 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5545 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5546 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5547 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5548 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5549 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5550 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5551 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5552 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5553 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5554 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5555 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5556 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5557 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5558 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5559 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5560 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5561 #ifdef HAVE_HWMON
5562 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5563 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5564 #ifdef HAVE_ADL
5565 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5566 #endif
5567 #endif // HAVE_HWMON
5568 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5569 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5570 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5571 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5572 // deprecated
5573 {"seperator", required_argument, 0, IDX_SEPARATOR},
5574 {"separator", required_argument, 0, IDX_SEPARATOR},
5575 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5576 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5577 {"increment", no_argument, 0, IDX_INCREMENT},
5578 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5579 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5580 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5581 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5582 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5583 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5584
5585 {0, 0, 0, 0}
5586 };
5587
5588 uint rp_files_cnt = 0;
5589
5590 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5591
5592 int option_index = 0;
5593 int c = -1;
5594
5595 optind = 1;
5596 optopt = 0;
5597
5598 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5599 {
5600 switch (c)
5601 {
5602 case IDX_HELP: usage = 1; break;
5603 case IDX_VERSION:
5604 case IDX_VERSION_LOWER: version = 1; break;
5605 case IDX_RESTORE: restore = 1; break;
5606 case IDX_SESSION: session = optarg; break;
5607 case IDX_SHOW: show = 1; break;
5608 case IDX_LEFT: left = 1; break;
5609 case '?': return (-1);
5610 }
5611 }
5612
5613 if (optopt != 0)
5614 {
5615 log_error ("ERROR: Invalid argument specified");
5616
5617 return (-1);
5618 }
5619
5620 /**
5621 * exit functions
5622 */
5623
5624 if (version)
5625 {
5626 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5627
5628 return (0);
5629 }
5630
5631 if (usage)
5632 {
5633 usage_big_print (PROGNAME);
5634
5635 return (0);
5636 }
5637
5638 /**
5639 * session needs to be set, always!
5640 */
5641
5642 if (session == NULL) session = (char *) PROGNAME;
5643
5644 /**
5645 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5646 */
5647
5648 char *exec_path = get_exec_path ();
5649
5650 #ifdef LINUX
5651
5652 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5653 char *resolved_exec_path = realpath (exec_path, NULL);
5654
5655 char *install_dir = get_install_dir (resolved_exec_path);
5656 char *profile_dir = NULL;
5657 char *session_dir = NULL;
5658 char *shared_dir = NULL;
5659
5660 if (strcmp (install_dir, resolved_install_folder) == 0)
5661 {
5662 struct passwd *pw = getpwuid (getuid ());
5663
5664 const char *homedir = pw->pw_dir;
5665
5666 profile_dir = get_profile_dir (homedir);
5667 session_dir = get_session_dir (profile_dir);
5668 shared_dir = strdup (SHARED_FOLDER);
5669
5670 mkdir (profile_dir, 0700);
5671 mkdir (session_dir, 0700);
5672 }
5673 else
5674 {
5675 profile_dir = install_dir;
5676 session_dir = install_dir;
5677 shared_dir = install_dir;
5678 }
5679
5680 myfree (resolved_install_folder);
5681 myfree (resolved_exec_path);
5682
5683 #else
5684
5685 char *install_dir = get_install_dir (exec_path);
5686 char *profile_dir = install_dir;
5687 char *session_dir = install_dir;
5688 char *shared_dir = install_dir;
5689
5690 #endif
5691
5692 data.install_dir = install_dir;
5693 data.profile_dir = profile_dir;
5694 data.session_dir = session_dir;
5695 data.shared_dir = shared_dir;
5696
5697 myfree (exec_path);
5698
5699 /**
5700 * kernel cache, we need to make sure folder exist
5701 */
5702
5703 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5704
5705 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5706
5707 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5708
5709 mkdir (kernels_folder, 0700);
5710
5711 myfree (kernels_folder);
5712
5713 /**
5714 * session
5715 */
5716
5717 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5718
5719 data.session = session;
5720
5721 char *eff_restore_file = (char *) mymalloc (session_size);
5722 char *new_restore_file = (char *) mymalloc (session_size);
5723
5724 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5725 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5726
5727 data.eff_restore_file = eff_restore_file;
5728 data.new_restore_file = new_restore_file;
5729
5730 if (((show == 1) || (left == 1)) && (restore == 1))
5731 {
5732 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5733 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5734
5735 return (-1);
5736 }
5737
5738 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5739 if ((show == 1) || (left == 1))
5740 {
5741 restore_disable = 1;
5742
5743 restore = 0;
5744 }
5745
5746 data.restore_disable = restore_disable;
5747
5748 restore_data_t *rd = init_restore (argc, argv);
5749
5750 data.rd = rd;
5751
5752 /**
5753 * restore file
5754 */
5755
5756 if (restore == 1)
5757 {
5758 read_restore (eff_restore_file, rd);
5759
5760 if (rd->version_bin < RESTORE_MIN)
5761 {
5762 log_error ("ERROR: Incompatible restore-file version");
5763
5764 return (-1);
5765 }
5766
5767 myargc = rd->argc;
5768 myargv = rd->argv;
5769
5770 #ifdef _POSIX
5771 rd->pid = getpid ();
5772 #elif _WIN
5773 rd->pid = GetCurrentProcessId ();
5774 #endif
5775 }
5776
5777 uint hash_mode_chgd = 0;
5778 uint runtime_chgd = 0;
5779 uint kernel_loops_chgd = 0;
5780 uint kernel_accel_chgd = 0;
5781 uint attack_mode_chgd = 0;
5782 uint outfile_format_chgd = 0;
5783 uint rp_gen_seed_chgd = 0;
5784 uint remove_timer_chgd = 0;
5785 uint increment_min_chgd = 0;
5786 uint increment_max_chgd = 0;
5787 uint workload_profile_chgd = 0;
5788 uint opencl_vector_width_chgd = 0;
5789
5790 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5791 uint gpu_temp_retain_chgd = 0;
5792 uint gpu_temp_abort_chgd = 0;
5793 #endif
5794
5795 optind = 1;
5796 optopt = 0;
5797 option_index = 0;
5798
5799 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5800 {
5801 switch (c)
5802 {
5803 //case IDX_HELP: usage = 1; break;
5804 //case IDX_VERSION: version = 1; break;
5805 //case IDX_RESTORE: restore = 1; break;
5806 case IDX_QUIET: quiet = 1; break;
5807 //case IDX_SHOW: show = 1; break;
5808 case IDX_SHOW: break;
5809 //case IDX_LEFT: left = 1; break;
5810 case IDX_LEFT: break;
5811 case IDX_USERNAME: username = 1; break;
5812 case IDX_REMOVE: remove = 1; break;
5813 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5814 remove_timer_chgd = 1; break;
5815 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5816 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5817 case IDX_DEBUG_FILE: debug_file = optarg; break;
5818 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5819 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5820 case IDX_FORCE: force = 1; break;
5821 case IDX_SKIP: skip = atoll (optarg); break;
5822 case IDX_LIMIT: limit = atoll (optarg); break;
5823 case IDX_KEYSPACE: keyspace = 1; break;
5824 case IDX_BENCHMARK: benchmark = 1; break;
5825 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5826 case IDX_RESTORE: break;
5827 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5828 case IDX_STATUS: status = 1; break;
5829 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5830 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5831 case IDX_LOOPBACK: loopback = 1; break;
5832 case IDX_WEAK_HASH_THRESHOLD:
5833 weak_hash_threshold = atoi (optarg); break;
5834 //case IDX_SESSION: session = optarg; break;
5835 case IDX_SESSION: break;
5836 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5837 hash_mode_chgd = 1; break;
5838 case IDX_RUNTIME: runtime = atoi (optarg);
5839 runtime_chgd = 1; break;
5840 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5841 attack_mode_chgd = 1; break;
5842 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5843 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5844 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5845 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5846 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5847 rp_gen_seed_chgd = 1; break;
5848 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5849 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5850 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5851 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5852 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5853 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5854 case IDX_OUTFILE: outfile = optarg; break;
5855 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5856 outfile_format_chgd = 1; break;
5857 case IDX_OUTFILE_AUTOHEX_DISABLE:
5858 outfile_autohex = 0; break;
5859 case IDX_OUTFILE_CHECK_TIMER:
5860 outfile_check_timer = atoi (optarg); break;
5861 case IDX_HEX_CHARSET: hex_charset = 1; break;
5862 case IDX_HEX_SALT: hex_salt = 1; break;
5863 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5864 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5865 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5866 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5867 case IDX_OPENCL_DEVICE_TYPES:
5868 opencl_device_types = optarg; break;
5869 case IDX_OPENCL_VECTOR_WIDTH:
5870 opencl_vector_width = atoi (optarg);
5871 opencl_vector_width_chgd = 1; break;
5872 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5873 workload_profile_chgd = 1; break;
5874 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5875 kernel_accel_chgd = 1; break;
5876 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5877 kernel_loops_chgd = 1; break;
5878 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5879 #ifdef HAVE_HWMON
5880 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5881 #ifdef HAVE_ADL
5882 gpu_temp_abort_chgd = 1;
5883 #endif
5884 break;
5885 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5886 #ifdef HAVE_ADL
5887 gpu_temp_retain_chgd = 1;
5888 #endif
5889 break;
5890 #ifdef HAVE_ADL
5891 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5892 #endif
5893 #endif // HAVE_HWMON
5894 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5895 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5896 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5897 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5898 case IDX_SEPARATOR: separator = optarg[0]; break;
5899 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5900 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5901 case IDX_INCREMENT: increment = 1; break;
5902 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5903 increment_min_chgd = 1; break;
5904 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5905 increment_max_chgd = 1; break;
5906 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5907 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5908 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5909 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5910
5911 default:
5912 log_error ("ERROR: Invalid argument specified");
5913 return (-1);
5914 }
5915 }
5916
5917 if (optopt != 0)
5918 {
5919 log_error ("ERROR: Invalid argument specified");
5920
5921 return (-1);
5922 }
5923
5924 /**
5925 * Inform user things getting started,
5926 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5927 * - we do not need to check algorithm_pos
5928 */
5929
5930 if (quiet == 0)
5931 {
5932 if (benchmark == 1)
5933 {
5934 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5935
5936 log_info ("");
5937 }
5938 else if (restore == 1)
5939 {
5940 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5941
5942 log_info ("");
5943 }
5944 else
5945 {
5946 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5947
5948 log_info ("");
5949 }
5950 }
5951
5952 /**
5953 * sanity check
5954 */
5955
5956 if (attack_mode > 7)
5957 {
5958 log_error ("ERROR: Invalid attack-mode specified");
5959
5960 return (-1);
5961 }
5962
5963 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5964 {
5965 log_error ("ERROR: Invalid runtime specified");
5966
5967 return (-1);
5968 }
5969
5970 if (hash_mode_chgd && hash_mode > 13200) // just added to remove compiler warnings for hash_mode_chgd
5971 {
5972 log_error ("ERROR: Invalid hash-type specified");
5973
5974 return (-1);
5975 }
5976
5977 // renamed hash modes
5978
5979 if (hash_mode_chgd)
5980 {
5981 int n = -1;
5982
5983 switch (hash_mode)
5984 {
5985 case 123: n = 124;
5986 break;
5987 }
5988
5989 if (n >= 0)
5990 {
5991 log_error ("Old -m specified, use -m %d instead", n);
5992
5993 return (-1);
5994 }
5995 }
5996
5997 if (username == 1)
5998 {
5999 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6000 {
6001 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6002
6003 return (-1);
6004 }
6005 }
6006
6007 if (outfile_format > 16)
6008 {
6009 log_error ("ERROR: Invalid outfile-format specified");
6010
6011 return (-1);
6012 }
6013
6014 if (left == 1)
6015 {
6016 if (outfile_format_chgd == 1)
6017 {
6018 if (outfile_format > 1)
6019 {
6020 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6021
6022 return (-1);
6023 }
6024 }
6025 else
6026 {
6027 outfile_format = OUTFILE_FMT_HASH;
6028 }
6029 }
6030
6031 if (show == 1)
6032 {
6033 if (outfile_format_chgd == 1)
6034 {
6035 if ((outfile_format > 7) && (outfile_format < 16))
6036 {
6037 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6038
6039 return (-1);
6040 }
6041 }
6042 }
6043
6044 if (increment_min < INCREMENT_MIN)
6045 {
6046 log_error ("ERROR: Invalid increment-min specified");
6047
6048 return (-1);
6049 }
6050
6051 if (increment_max > INCREMENT_MAX)
6052 {
6053 log_error ("ERROR: Invalid increment-max specified");
6054
6055 return (-1);
6056 }
6057
6058 if (increment_min > increment_max)
6059 {
6060 log_error ("ERROR: Invalid increment-min specified");
6061
6062 return (-1);
6063 }
6064
6065 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6066 {
6067 log_error ("ERROR: increment is not allowed in attack-mode 0");
6068
6069 return (-1);
6070 }
6071
6072 if ((increment == 0) && (increment_min_chgd == 1))
6073 {
6074 log_error ("ERROR: increment-min is only supported together with increment switch");
6075
6076 return (-1);
6077 }
6078
6079 if ((increment == 0) && (increment_max_chgd == 1))
6080 {
6081 log_error ("ERROR: increment-max is only supported together with increment switch");
6082
6083 return (-1);
6084 }
6085
6086 if (rp_files_cnt && rp_gen)
6087 {
6088 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6089
6090 return (-1);
6091 }
6092
6093 if (rp_files_cnt || rp_gen)
6094 {
6095 if (attack_mode != ATTACK_MODE_STRAIGHT)
6096 {
6097 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6098
6099 return (-1);
6100 }
6101 }
6102
6103 if (rp_gen_func_min > rp_gen_func_max)
6104 {
6105 log_error ("ERROR: Invalid rp-gen-func-min specified");
6106
6107 return (-1);
6108 }
6109
6110 if (kernel_accel_chgd == 1)
6111 {
6112 if (kernel_accel < 1)
6113 {
6114 log_error ("ERROR: Invalid kernel-accel specified");
6115
6116 return (-1);
6117 }
6118
6119 if (kernel_accel > 1024)
6120 {
6121 log_error ("ERROR: Invalid kernel-accel specified");
6122
6123 return (-1);
6124 }
6125 }
6126
6127 if (kernel_loops_chgd == 1)
6128 {
6129 if (kernel_loops < 1)
6130 {
6131 log_error ("ERROR: Invalid kernel-loops specified");
6132
6133 return (-1);
6134 }
6135
6136 if (kernel_loops > 1024)
6137 {
6138 log_error ("ERROR: Invalid kernel-loops specified");
6139
6140 return (-1);
6141 }
6142 }
6143
6144 if ((workload_profile < 1) || (workload_profile > 3))
6145 {
6146 log_error ("ERROR: workload-profile %i not available", workload_profile);
6147
6148 return (-1);
6149 }
6150
6151 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6152 {
6153 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6154
6155 return (-1);
6156 }
6157
6158 if (show == 1 || left == 1)
6159 {
6160 attack_mode = ATTACK_MODE_NONE;
6161
6162 if (remove == 1)
6163 {
6164 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6165
6166 return (-1);
6167 }
6168
6169 if (potfile_disable == 1)
6170 {
6171 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6172
6173 return (-1);
6174 }
6175 }
6176
6177 uint attack_kern = ATTACK_KERN_NONE;
6178
6179 switch (attack_mode)
6180 {
6181 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6182 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6183 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6184 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6185 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6186 }
6187
6188 if (benchmark == 0)
6189 {
6190 if (keyspace == 1)
6191 {
6192 int num_additional_params = 1;
6193
6194 if (attack_kern == ATTACK_KERN_COMBI)
6195 {
6196 num_additional_params = 2;
6197 }
6198
6199 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6200
6201 if (keyspace_wordlist_specified == 0) optind--;
6202 }
6203
6204 if (attack_kern == ATTACK_KERN_NONE)
6205 {
6206 if ((optind + 1) != myargc)
6207 {
6208 usage_mini_print (myargv[0]);
6209
6210 return (-1);
6211 }
6212 }
6213 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6214 {
6215 if ((optind + 1) > myargc)
6216 {
6217 usage_mini_print (myargv[0]);
6218
6219 return (-1);
6220 }
6221 }
6222 else if (attack_kern == ATTACK_KERN_COMBI)
6223 {
6224 if ((optind + 3) != myargc)
6225 {
6226 usage_mini_print (myargv[0]);
6227
6228 return (-1);
6229 }
6230 }
6231 else if (attack_kern == ATTACK_KERN_BF)
6232 {
6233 if ((optind + 1) > myargc)
6234 {
6235 usage_mini_print (myargv[0]);
6236
6237 return (-1);
6238 }
6239 }
6240 else
6241 {
6242 usage_mini_print (myargv[0]);
6243
6244 return (-1);
6245 }
6246 }
6247 else
6248 {
6249 if (myargv[optind] != 0)
6250 {
6251 log_error ("ERROR: Invalid argument for benchmark mode specified");
6252
6253 return (-1);
6254 }
6255
6256 if (attack_mode_chgd == 1)
6257 {
6258 if (attack_mode != ATTACK_MODE_BF)
6259 {
6260 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6261
6262 return (-1);
6263 }
6264 }
6265 }
6266
6267 if (skip != 0 && limit != 0)
6268 {
6269 limit += skip;
6270 }
6271
6272 if (keyspace == 1)
6273 {
6274 if (show == 1)
6275 {
6276 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6277
6278 return (-1);
6279 }
6280 else if (left == 1)
6281 {
6282 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6283
6284 return (-1);
6285 }
6286
6287 potfile_disable = 1;
6288
6289 restore_disable = 1;
6290
6291 restore = 0;
6292
6293 weak_hash_threshold = 0;
6294
6295 quiet = 1;
6296 }
6297
6298 if (remove_timer_chgd == 1)
6299 {
6300 if (remove == 0)
6301 {
6302 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6303
6304 return (-1);
6305 }
6306
6307 if (remove_timer < 1)
6308 {
6309 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6310
6311 return (-1);
6312 }
6313 }
6314
6315 if (loopback == 1)
6316 {
6317 if (attack_mode == ATTACK_MODE_BF)
6318 {
6319 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6320
6321 return (-1);
6322 }
6323 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6324 {
6325 if ((rp_files_cnt == 0) && (rp_gen == 0))
6326 {
6327 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6328
6329 return (-1);
6330 }
6331 }
6332 }
6333
6334 if (debug_mode > 0)
6335 {
6336 if (attack_mode != ATTACK_MODE_STRAIGHT)
6337 {
6338 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6339
6340 return (-1);
6341 }
6342
6343 if ((rp_files_cnt == 0) && (rp_gen == 0))
6344 {
6345 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6346
6347 return (-1);
6348 }
6349 }
6350
6351 if (debug_mode > 4)
6352 {
6353 log_error ("ERROR: Invalid debug-mode specified");
6354
6355 return (-1);
6356 }
6357
6358 if (debug_file != NULL)
6359 {
6360 if (debug_mode < 1)
6361 {
6362 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6363
6364 return (-1);
6365 }
6366 }
6367
6368 if (induction_dir != NULL)
6369 {
6370 if (attack_mode == ATTACK_MODE_BF)
6371 {
6372 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6373
6374 return (-1);
6375 }
6376 }
6377
6378 if (attack_mode != ATTACK_MODE_STRAIGHT)
6379 {
6380 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6381 {
6382 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6383
6384 return (-1);
6385 }
6386
6387 weak_hash_threshold = 0;
6388 }
6389
6390 /**
6391 * induction directory
6392 */
6393
6394 char *induction_directory = NULL;
6395
6396 if (attack_mode != ATTACK_MODE_BF)
6397 {
6398 if (induction_dir == NULL)
6399 {
6400 induction_directory = (char *) mymalloc (session_size);
6401
6402 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6403
6404 // create induction folder if it does not already exist
6405
6406 if (keyspace == 0)
6407 {
6408 if (rmdir (induction_directory) == -1)
6409 {
6410 if (errno == ENOENT)
6411 {
6412 // good, we can ignore
6413 }
6414 else if (errno == ENOTEMPTY)
6415 {
6416 char *induction_directory_mv = (char *) mymalloc (session_size);
6417
6418 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6419
6420 if (rename (induction_directory, induction_directory_mv) != 0)
6421 {
6422 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6423
6424 return (-1);
6425 }
6426 }
6427 else
6428 {
6429 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6430
6431 return (-1);
6432 }
6433 }
6434
6435 if (mkdir (induction_directory, 0700) == -1)
6436 {
6437 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6438
6439 return (-1);
6440 }
6441 }
6442 }
6443 else
6444 {
6445 induction_directory = induction_dir;
6446 }
6447 }
6448
6449 data.induction_directory = induction_directory;
6450
6451 /**
6452 * loopback
6453 */
6454
6455 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6456
6457 char *loopback_file = (char *) mymalloc (loopback_size);
6458
6459 /**
6460 * tuning db
6461 */
6462
6463 char tuning_db_file[256] = { 0 };
6464
6465 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6466
6467 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6468
6469 /**
6470 * outfile-check directory
6471 */
6472
6473 char *outfile_check_directory = NULL;
6474
6475 if (outfile_check_dir == NULL)
6476 {
6477 outfile_check_directory = (char *) mymalloc (session_size);
6478
6479 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6480 }
6481 else
6482 {
6483 outfile_check_directory = outfile_check_dir;
6484 }
6485
6486 data.outfile_check_directory = outfile_check_directory;
6487
6488 if (keyspace == 0)
6489 {
6490 struct stat outfile_check_stat;
6491
6492 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6493 {
6494 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6495
6496 if (is_dir == 0)
6497 {
6498 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6499
6500 return (-1);
6501 }
6502 }
6503 else if (outfile_check_dir == NULL)
6504 {
6505 if (mkdir (outfile_check_directory, 0700) == -1)
6506 {
6507 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6508
6509 return (-1);
6510 }
6511 }
6512 }
6513
6514 /**
6515 * special other stuff
6516 */
6517
6518 if (hash_mode == 9710)
6519 {
6520 outfile_format = 5;
6521 outfile_format_chgd = 1;
6522 }
6523
6524 if (hash_mode == 9810)
6525 {
6526 outfile_format = 5;
6527 outfile_format_chgd = 1;
6528 }
6529
6530 if (hash_mode == 10410)
6531 {
6532 outfile_format = 5;
6533 outfile_format_chgd = 1;
6534 }
6535
6536 /**
6537 * store stuff
6538 */
6539
6540 data.hash_mode = hash_mode;
6541 data.restore = restore;
6542 data.restore_timer = restore_timer;
6543 data.restore_disable = restore_disable;
6544 data.status = status;
6545 data.status_timer = status_timer;
6546 data.status_automat = status_automat;
6547 data.loopback = loopback;
6548 data.runtime = runtime;
6549 data.remove = remove;
6550 data.remove_timer = remove_timer;
6551 data.debug_mode = debug_mode;
6552 data.debug_file = debug_file;
6553 data.username = username;
6554 data.quiet = quiet;
6555 data.outfile = outfile;
6556 data.outfile_format = outfile_format;
6557 data.outfile_autohex = outfile_autohex;
6558 data.hex_charset = hex_charset;
6559 data.hex_salt = hex_salt;
6560 data.hex_wordlist = hex_wordlist;
6561 data.separator = separator;
6562 data.rp_files = rp_files;
6563 data.rp_files_cnt = rp_files_cnt;
6564 data.rp_gen = rp_gen;
6565 data.rp_gen_seed = rp_gen_seed;
6566 data.force = force;
6567 data.benchmark = benchmark;
6568 data.benchmark_repeats = benchmark_repeats;
6569 data.skip = skip;
6570 data.limit = limit;
6571 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6572 data.powertune_enable = powertune_enable;
6573 #endif
6574 data.logfile_disable = logfile_disable;
6575 data.truecrypt_keyfiles = truecrypt_keyfiles;
6576 data.scrypt_tmto = scrypt_tmto;
6577 data.workload_profile = workload_profile;
6578
6579 /**
6580 * cpu affinity
6581 */
6582
6583 if (cpu_affinity)
6584 {
6585 set_cpu_affinity (cpu_affinity);
6586 }
6587
6588 if (rp_gen_seed_chgd == 0)
6589 {
6590 srand (proc_start);
6591 }
6592 else
6593 {
6594 srand (rp_gen_seed);
6595 }
6596
6597 /**
6598 * logfile init
6599 */
6600
6601 if (logfile_disable == 0)
6602 {
6603 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6604
6605 char *logfile = (char *) mymalloc (logfile_size);
6606
6607 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6608
6609 data.logfile = logfile;
6610
6611 char *topid = logfile_generate_topid ();
6612
6613 data.topid = topid;
6614 }
6615
6616 // logfile_append() checks for logfile_disable internally to make it easier from here
6617
6618 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6619 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6620 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6621 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6622 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6623 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6624 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6625 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6626 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6627 #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));
6628
6629 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6630 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6631 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6632 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6633 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6634 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6635 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6636 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6637
6638 logfile_top_msg ("START");
6639
6640 logfile_top_uint (attack_mode);
6641 logfile_top_uint (attack_kern);
6642 logfile_top_uint (benchmark);
6643 logfile_top_uint (benchmark_repeats);
6644 logfile_top_uint (bitmap_min);
6645 logfile_top_uint (bitmap_max);
6646 logfile_top_uint (debug_mode);
6647 logfile_top_uint (force);
6648 logfile_top_uint (kernel_accel);
6649 logfile_top_uint (kernel_loops);
6650 logfile_top_uint (gpu_temp_disable);
6651 #ifdef HAVE_HWMON
6652 logfile_top_uint (gpu_temp_abort);
6653 logfile_top_uint (gpu_temp_retain);
6654 #endif
6655 logfile_top_uint (hash_mode);
6656 logfile_top_uint (hex_charset);
6657 logfile_top_uint (hex_salt);
6658 logfile_top_uint (hex_wordlist);
6659 logfile_top_uint (increment);
6660 logfile_top_uint (increment_max);
6661 logfile_top_uint (increment_min);
6662 logfile_top_uint (keyspace);
6663 logfile_top_uint (left);
6664 logfile_top_uint (logfile_disable);
6665 logfile_top_uint (loopback);
6666 logfile_top_uint (markov_classic);
6667 logfile_top_uint (markov_disable);
6668 logfile_top_uint (markov_threshold);
6669 logfile_top_uint (outfile_autohex);
6670 logfile_top_uint (outfile_check_timer);
6671 logfile_top_uint (outfile_format);
6672 logfile_top_uint (potfile_disable);
6673 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6674 logfile_top_uint (powertune_enable);
6675 #endif
6676 logfile_top_uint (scrypt_tmto);
6677 logfile_top_uint (quiet);
6678 logfile_top_uint (remove);
6679 logfile_top_uint (remove_timer);
6680 logfile_top_uint (restore);
6681 logfile_top_uint (restore_disable);
6682 logfile_top_uint (restore_timer);
6683 logfile_top_uint (rp_gen);
6684 logfile_top_uint (rp_gen_func_max);
6685 logfile_top_uint (rp_gen_func_min);
6686 logfile_top_uint (rp_gen_seed);
6687 logfile_top_uint (runtime);
6688 logfile_top_uint (segment_size);
6689 logfile_top_uint (show);
6690 logfile_top_uint (status);
6691 logfile_top_uint (status_automat);
6692 logfile_top_uint (status_timer);
6693 logfile_top_uint (usage);
6694 logfile_top_uint (username);
6695 logfile_top_uint (version);
6696 logfile_top_uint (weak_hash_threshold);
6697 logfile_top_uint (workload_profile);
6698 logfile_top_uint64 (limit);
6699 logfile_top_uint64 (skip);
6700 logfile_top_char (separator);
6701 logfile_top_string (cpu_affinity);
6702 logfile_top_string (custom_charset_1);
6703 logfile_top_string (custom_charset_2);
6704 logfile_top_string (custom_charset_3);
6705 logfile_top_string (custom_charset_4);
6706 logfile_top_string (debug_file);
6707 logfile_top_string (opencl_devices);
6708 logfile_top_string (opencl_platforms);
6709 logfile_top_string (opencl_device_types);
6710 logfile_top_uint (opencl_vector_width);
6711 logfile_top_string (induction_dir);
6712 logfile_top_string (markov_hcstat);
6713 logfile_top_string (outfile);
6714 logfile_top_string (outfile_check_dir);
6715 logfile_top_string (rule_buf_l);
6716 logfile_top_string (rule_buf_r);
6717 logfile_top_string (session);
6718 logfile_top_string (truecrypt_keyfiles);
6719
6720 /**
6721 * Init OpenCL library loader
6722 */
6723
6724 if (keyspace == 0)
6725 {
6726 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6727
6728 ocl_init (ocl);
6729
6730 data.ocl = ocl;
6731 }
6732
6733 /**
6734 * OpenCL platform selection
6735 */
6736
6737 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6738
6739 /**
6740 * OpenCL device selection
6741 */
6742
6743 u32 devices_filter = setup_devices_filter (opencl_devices);
6744
6745 /**
6746 * OpenCL device type selection
6747 */
6748
6749 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6750
6751 /**
6752 * benchmark
6753 */
6754
6755 if (benchmark == 1)
6756 {
6757 /**
6758 * disable useless stuff for benchmark
6759 */
6760
6761 status_timer = 0;
6762 restore_timer = 0;
6763 restore_disable = 1;
6764 potfile_disable = 1;
6765 weak_hash_threshold = 0;
6766 gpu_temp_disable = 1;
6767
6768 data.status_timer = status_timer;
6769 data.restore_timer = restore_timer;
6770 data.restore_disable = restore_disable;
6771
6772 /**
6773 * force attack mode to be bruteforce
6774 */
6775
6776 attack_mode = ATTACK_MODE_BF;
6777 attack_kern = ATTACK_KERN_BF;
6778
6779 if (workload_profile_chgd == 0)
6780 {
6781 workload_profile = 3;
6782
6783 data.workload_profile = workload_profile;
6784 }
6785 }
6786
6787 /**
6788 * config
6789 */
6790
6791 uint hash_type = 0;
6792 uint salt_type = 0;
6793 uint attack_exec = 0;
6794 uint opts_type = 0;
6795 uint kern_type = 0;
6796 uint dgst_size = 0;
6797 uint esalt_size = 0;
6798 uint opti_type = 0;
6799 uint dgst_pos0 = -1;
6800 uint dgst_pos1 = -1;
6801 uint dgst_pos2 = -1;
6802 uint dgst_pos3 = -1;
6803
6804 int (*parse_func) (char *, uint, hash_t *);
6805 int (*sort_by_digest) (const void *, const void *);
6806
6807 uint algorithm_pos = 0;
6808 uint algorithm_max = 1;
6809
6810 uint *algorithms = default_benchmark_algorithms;
6811
6812 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6813
6814 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6815 {
6816 /*
6817 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6818 * the following algos are skipped entirely
6819 */
6820
6821 if (algorithm_pos > 0)
6822 {
6823 local_free (rd);
6824
6825 rd = init_restore (argc, argv);
6826
6827 data.rd = rd;
6828 }
6829
6830 /**
6831 * update hash_mode in case of multihash benchmark
6832 */
6833
6834 if (benchmark == 1)
6835 {
6836 if (hash_mode_chgd == 0)
6837 {
6838 hash_mode = algorithms[algorithm_pos];
6839
6840 data.hash_mode = hash_mode;
6841 }
6842
6843 quiet = 1;
6844
6845 data.quiet = quiet;
6846 }
6847
6848 switch (hash_mode)
6849 {
6850 case 0: hash_type = HASH_TYPE_MD5;
6851 salt_type = SALT_TYPE_NONE;
6852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6853 opts_type = OPTS_TYPE_PT_GENERATE_LE
6854 | OPTS_TYPE_PT_ADD80
6855 | OPTS_TYPE_PT_ADDBITS14;
6856 kern_type = KERN_TYPE_MD5;
6857 dgst_size = DGST_SIZE_4_4;
6858 parse_func = md5_parse_hash;
6859 sort_by_digest = sort_by_digest_4_4;
6860 opti_type = OPTI_TYPE_ZERO_BYTE
6861 | OPTI_TYPE_PRECOMPUTE_INIT
6862 | OPTI_TYPE_PRECOMPUTE_MERKLE
6863 | OPTI_TYPE_MEET_IN_MIDDLE
6864 | OPTI_TYPE_EARLY_SKIP
6865 | OPTI_TYPE_NOT_ITERATED
6866 | OPTI_TYPE_NOT_SALTED
6867 | OPTI_TYPE_RAW_HASH;
6868 dgst_pos0 = 0;
6869 dgst_pos1 = 3;
6870 dgst_pos2 = 2;
6871 dgst_pos3 = 1;
6872 break;
6873
6874 case 10: hash_type = HASH_TYPE_MD5;
6875 salt_type = SALT_TYPE_INTERN;
6876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6877 opts_type = OPTS_TYPE_PT_GENERATE_LE
6878 | OPTS_TYPE_ST_ADD80
6879 | OPTS_TYPE_ST_ADDBITS14;
6880 kern_type = KERN_TYPE_MD5_PWSLT;
6881 dgst_size = DGST_SIZE_4_4;
6882 parse_func = md5s_parse_hash;
6883 sort_by_digest = sort_by_digest_4_4;
6884 opti_type = OPTI_TYPE_ZERO_BYTE
6885 | OPTI_TYPE_PRECOMPUTE_INIT
6886 | OPTI_TYPE_PRECOMPUTE_MERKLE
6887 | OPTI_TYPE_MEET_IN_MIDDLE
6888 | OPTI_TYPE_EARLY_SKIP
6889 | OPTI_TYPE_NOT_ITERATED
6890 | OPTI_TYPE_APPENDED_SALT
6891 | OPTI_TYPE_RAW_HASH;
6892 dgst_pos0 = 0;
6893 dgst_pos1 = 3;
6894 dgst_pos2 = 2;
6895 dgst_pos3 = 1;
6896 break;
6897
6898 case 11: hash_type = HASH_TYPE_MD5;
6899 salt_type = SALT_TYPE_INTERN;
6900 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6901 opts_type = OPTS_TYPE_PT_GENERATE_LE
6902 | OPTS_TYPE_ST_ADD80
6903 | OPTS_TYPE_ST_ADDBITS14;
6904 kern_type = KERN_TYPE_MD5_PWSLT;
6905 dgst_size = DGST_SIZE_4_4;
6906 parse_func = joomla_parse_hash;
6907 sort_by_digest = sort_by_digest_4_4;
6908 opti_type = OPTI_TYPE_ZERO_BYTE
6909 | OPTI_TYPE_PRECOMPUTE_INIT
6910 | OPTI_TYPE_PRECOMPUTE_MERKLE
6911 | OPTI_TYPE_MEET_IN_MIDDLE
6912 | OPTI_TYPE_EARLY_SKIP
6913 | OPTI_TYPE_NOT_ITERATED
6914 | OPTI_TYPE_APPENDED_SALT
6915 | OPTI_TYPE_RAW_HASH;
6916 dgst_pos0 = 0;
6917 dgst_pos1 = 3;
6918 dgst_pos2 = 2;
6919 dgst_pos3 = 1;
6920 break;
6921
6922 case 12: hash_type = HASH_TYPE_MD5;
6923 salt_type = SALT_TYPE_INTERN;
6924 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6925 opts_type = OPTS_TYPE_PT_GENERATE_LE
6926 | OPTS_TYPE_ST_ADD80
6927 | OPTS_TYPE_ST_ADDBITS14;
6928 kern_type = KERN_TYPE_MD5_PWSLT;
6929 dgst_size = DGST_SIZE_4_4;
6930 parse_func = postgresql_parse_hash;
6931 sort_by_digest = sort_by_digest_4_4;
6932 opti_type = OPTI_TYPE_ZERO_BYTE
6933 | OPTI_TYPE_PRECOMPUTE_INIT
6934 | OPTI_TYPE_PRECOMPUTE_MERKLE
6935 | OPTI_TYPE_MEET_IN_MIDDLE
6936 | OPTI_TYPE_EARLY_SKIP
6937 | OPTI_TYPE_NOT_ITERATED
6938 | OPTI_TYPE_APPENDED_SALT
6939 | OPTI_TYPE_RAW_HASH;
6940 dgst_pos0 = 0;
6941 dgst_pos1 = 3;
6942 dgst_pos2 = 2;
6943 dgst_pos3 = 1;
6944 break;
6945
6946 case 20: hash_type = HASH_TYPE_MD5;
6947 salt_type = SALT_TYPE_INTERN;
6948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6949 opts_type = OPTS_TYPE_PT_GENERATE_LE
6950 | OPTS_TYPE_PT_ADD80
6951 | OPTS_TYPE_PT_ADDBITS14;
6952 kern_type = KERN_TYPE_MD5_SLTPW;
6953 dgst_size = DGST_SIZE_4_4;
6954 parse_func = md5s_parse_hash;
6955 sort_by_digest = sort_by_digest_4_4;
6956 opti_type = OPTI_TYPE_ZERO_BYTE
6957 | OPTI_TYPE_PRECOMPUTE_INIT
6958 | OPTI_TYPE_PRECOMPUTE_MERKLE
6959 | OPTI_TYPE_EARLY_SKIP
6960 | OPTI_TYPE_NOT_ITERATED
6961 | OPTI_TYPE_PREPENDED_SALT
6962 | OPTI_TYPE_RAW_HASH;
6963 dgst_pos0 = 0;
6964 dgst_pos1 = 3;
6965 dgst_pos2 = 2;
6966 dgst_pos3 = 1;
6967 break;
6968
6969 case 21: hash_type = HASH_TYPE_MD5;
6970 salt_type = SALT_TYPE_INTERN;
6971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6972 opts_type = OPTS_TYPE_PT_GENERATE_LE
6973 | OPTS_TYPE_PT_ADD80
6974 | OPTS_TYPE_PT_ADDBITS14;
6975 kern_type = KERN_TYPE_MD5_SLTPW;
6976 dgst_size = DGST_SIZE_4_4;
6977 parse_func = osc_parse_hash;
6978 sort_by_digest = sort_by_digest_4_4;
6979 opti_type = OPTI_TYPE_ZERO_BYTE
6980 | OPTI_TYPE_PRECOMPUTE_INIT
6981 | OPTI_TYPE_PRECOMPUTE_MERKLE
6982 | OPTI_TYPE_EARLY_SKIP
6983 | OPTI_TYPE_NOT_ITERATED
6984 | OPTI_TYPE_PREPENDED_SALT
6985 | OPTI_TYPE_RAW_HASH;
6986 dgst_pos0 = 0;
6987 dgst_pos1 = 3;
6988 dgst_pos2 = 2;
6989 dgst_pos3 = 1;
6990 break;
6991
6992 case 22: hash_type = HASH_TYPE_MD5;
6993 salt_type = SALT_TYPE_EMBEDDED;
6994 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6995 opts_type = OPTS_TYPE_PT_GENERATE_LE
6996 | OPTS_TYPE_PT_ADD80
6997 | OPTS_TYPE_PT_ADDBITS14;
6998 kern_type = KERN_TYPE_MD5_SLTPW;
6999 dgst_size = DGST_SIZE_4_4;
7000 parse_func = netscreen_parse_hash;
7001 sort_by_digest = sort_by_digest_4_4;
7002 opti_type = OPTI_TYPE_ZERO_BYTE
7003 | OPTI_TYPE_PRECOMPUTE_INIT
7004 | OPTI_TYPE_PRECOMPUTE_MERKLE
7005 | OPTI_TYPE_EARLY_SKIP
7006 | OPTI_TYPE_NOT_ITERATED
7007 | OPTI_TYPE_PREPENDED_SALT
7008 | OPTI_TYPE_RAW_HASH;
7009 dgst_pos0 = 0;
7010 dgst_pos1 = 3;
7011 dgst_pos2 = 2;
7012 dgst_pos3 = 1;
7013 break;
7014
7015 case 23: hash_type = HASH_TYPE_MD5;
7016 salt_type = SALT_TYPE_EMBEDDED;
7017 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7018 opts_type = OPTS_TYPE_PT_GENERATE_LE
7019 | OPTS_TYPE_PT_ADD80
7020 | OPTS_TYPE_PT_ADDBITS14;
7021 kern_type = KERN_TYPE_MD5_SLTPW;
7022 dgst_size = DGST_SIZE_4_4;
7023 parse_func = skype_parse_hash;
7024 sort_by_digest = sort_by_digest_4_4;
7025 opti_type = OPTI_TYPE_ZERO_BYTE
7026 | OPTI_TYPE_PRECOMPUTE_INIT
7027 | OPTI_TYPE_PRECOMPUTE_MERKLE
7028 | OPTI_TYPE_EARLY_SKIP
7029 | OPTI_TYPE_NOT_ITERATED
7030 | OPTI_TYPE_PREPENDED_SALT
7031 | OPTI_TYPE_RAW_HASH;
7032 dgst_pos0 = 0;
7033 dgst_pos1 = 3;
7034 dgst_pos2 = 2;
7035 dgst_pos3 = 1;
7036 break;
7037
7038 case 30: hash_type = HASH_TYPE_MD5;
7039 salt_type = SALT_TYPE_INTERN;
7040 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7041 opts_type = OPTS_TYPE_PT_GENERATE_LE
7042 | OPTS_TYPE_PT_UNICODE
7043 | OPTS_TYPE_ST_ADD80
7044 | OPTS_TYPE_ST_ADDBITS14;
7045 kern_type = KERN_TYPE_MD5_PWUSLT;
7046 dgst_size = DGST_SIZE_4_4;
7047 parse_func = md5s_parse_hash;
7048 sort_by_digest = sort_by_digest_4_4;
7049 opti_type = OPTI_TYPE_ZERO_BYTE
7050 | OPTI_TYPE_PRECOMPUTE_INIT
7051 | OPTI_TYPE_PRECOMPUTE_MERKLE
7052 | OPTI_TYPE_MEET_IN_MIDDLE
7053 | OPTI_TYPE_EARLY_SKIP
7054 | OPTI_TYPE_NOT_ITERATED
7055 | OPTI_TYPE_APPENDED_SALT
7056 | OPTI_TYPE_RAW_HASH;
7057 dgst_pos0 = 0;
7058 dgst_pos1 = 3;
7059 dgst_pos2 = 2;
7060 dgst_pos3 = 1;
7061 break;
7062
7063 case 40: hash_type = HASH_TYPE_MD5;
7064 salt_type = SALT_TYPE_INTERN;
7065 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7066 opts_type = OPTS_TYPE_PT_GENERATE_LE
7067 | OPTS_TYPE_PT_ADD80
7068 | OPTS_TYPE_PT_ADDBITS14
7069 | OPTS_TYPE_PT_UNICODE;
7070 kern_type = KERN_TYPE_MD5_SLTPWU;
7071 dgst_size = DGST_SIZE_4_4;
7072 parse_func = md5s_parse_hash;
7073 sort_by_digest = sort_by_digest_4_4;
7074 opti_type = OPTI_TYPE_ZERO_BYTE
7075 | OPTI_TYPE_PRECOMPUTE_INIT
7076 | OPTI_TYPE_PRECOMPUTE_MERKLE
7077 | OPTI_TYPE_EARLY_SKIP
7078 | OPTI_TYPE_NOT_ITERATED
7079 | OPTI_TYPE_PREPENDED_SALT
7080 | OPTI_TYPE_RAW_HASH;
7081 dgst_pos0 = 0;
7082 dgst_pos1 = 3;
7083 dgst_pos2 = 2;
7084 dgst_pos3 = 1;
7085 break;
7086
7087 case 50: hash_type = HASH_TYPE_MD5;
7088 salt_type = SALT_TYPE_INTERN;
7089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7090 opts_type = OPTS_TYPE_PT_GENERATE_LE
7091 | OPTS_TYPE_ST_ADD80
7092 | OPTS_TYPE_ST_ADDBITS14;
7093 kern_type = KERN_TYPE_HMACMD5_PW;
7094 dgst_size = DGST_SIZE_4_4;
7095 parse_func = hmacmd5_parse_hash;
7096 sort_by_digest = sort_by_digest_4_4;
7097 opti_type = OPTI_TYPE_ZERO_BYTE
7098 | OPTI_TYPE_NOT_ITERATED;
7099 dgst_pos0 = 0;
7100 dgst_pos1 = 3;
7101 dgst_pos2 = 2;
7102 dgst_pos3 = 1;
7103 break;
7104
7105 case 60: hash_type = HASH_TYPE_MD5;
7106 salt_type = SALT_TYPE_INTERN;
7107 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7108 opts_type = OPTS_TYPE_PT_GENERATE_LE
7109 | OPTS_TYPE_PT_ADD80
7110 | OPTS_TYPE_PT_ADDBITS14;
7111 kern_type = KERN_TYPE_HMACMD5_SLT;
7112 dgst_size = DGST_SIZE_4_4;
7113 parse_func = hmacmd5_parse_hash;
7114 sort_by_digest = sort_by_digest_4_4;
7115 opti_type = OPTI_TYPE_ZERO_BYTE
7116 | OPTI_TYPE_NOT_ITERATED;
7117 dgst_pos0 = 0;
7118 dgst_pos1 = 3;
7119 dgst_pos2 = 2;
7120 dgst_pos3 = 1;
7121 break;
7122
7123 case 100: hash_type = HASH_TYPE_SHA1;
7124 salt_type = SALT_TYPE_NONE;
7125 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7126 opts_type = OPTS_TYPE_PT_GENERATE_BE
7127 | OPTS_TYPE_PT_ADD80
7128 | OPTS_TYPE_PT_ADDBITS15;
7129 kern_type = KERN_TYPE_SHA1;
7130 dgst_size = DGST_SIZE_4_5;
7131 parse_func = sha1_parse_hash;
7132 sort_by_digest = sort_by_digest_4_5;
7133 opti_type = OPTI_TYPE_ZERO_BYTE
7134 | OPTI_TYPE_PRECOMPUTE_INIT
7135 | OPTI_TYPE_PRECOMPUTE_MERKLE
7136 | OPTI_TYPE_EARLY_SKIP
7137 | OPTI_TYPE_NOT_ITERATED
7138 | OPTI_TYPE_NOT_SALTED
7139 | OPTI_TYPE_RAW_HASH;
7140 dgst_pos0 = 3;
7141 dgst_pos1 = 4;
7142 dgst_pos2 = 2;
7143 dgst_pos3 = 1;
7144 break;
7145
7146 case 101: hash_type = HASH_TYPE_SHA1;
7147 salt_type = SALT_TYPE_NONE;
7148 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7149 opts_type = OPTS_TYPE_PT_GENERATE_BE
7150 | OPTS_TYPE_PT_ADD80
7151 | OPTS_TYPE_PT_ADDBITS15;
7152 kern_type = KERN_TYPE_SHA1;
7153 dgst_size = DGST_SIZE_4_5;
7154 parse_func = sha1b64_parse_hash;
7155 sort_by_digest = sort_by_digest_4_5;
7156 opti_type = OPTI_TYPE_ZERO_BYTE
7157 | OPTI_TYPE_PRECOMPUTE_INIT
7158 | OPTI_TYPE_PRECOMPUTE_MERKLE
7159 | OPTI_TYPE_EARLY_SKIP
7160 | OPTI_TYPE_NOT_ITERATED
7161 | OPTI_TYPE_NOT_SALTED
7162 | OPTI_TYPE_RAW_HASH;
7163 dgst_pos0 = 3;
7164 dgst_pos1 = 4;
7165 dgst_pos2 = 2;
7166 dgst_pos3 = 1;
7167 break;
7168
7169 case 110: hash_type = HASH_TYPE_SHA1;
7170 salt_type = SALT_TYPE_INTERN;
7171 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7172 opts_type = OPTS_TYPE_PT_GENERATE_BE
7173 | OPTS_TYPE_ST_ADD80
7174 | OPTS_TYPE_ST_ADDBITS15;
7175 kern_type = KERN_TYPE_SHA1_PWSLT;
7176 dgst_size = DGST_SIZE_4_5;
7177 parse_func = sha1s_parse_hash;
7178 sort_by_digest = sort_by_digest_4_5;
7179 opti_type = OPTI_TYPE_ZERO_BYTE
7180 | OPTI_TYPE_PRECOMPUTE_INIT
7181 | OPTI_TYPE_PRECOMPUTE_MERKLE
7182 | OPTI_TYPE_EARLY_SKIP
7183 | OPTI_TYPE_NOT_ITERATED
7184 | OPTI_TYPE_APPENDED_SALT
7185 | OPTI_TYPE_RAW_HASH;
7186 dgst_pos0 = 3;
7187 dgst_pos1 = 4;
7188 dgst_pos2 = 2;
7189 dgst_pos3 = 1;
7190 break;
7191
7192 case 111: hash_type = HASH_TYPE_SHA1;
7193 salt_type = SALT_TYPE_EMBEDDED;
7194 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7195 opts_type = OPTS_TYPE_PT_GENERATE_BE
7196 | OPTS_TYPE_ST_ADD80
7197 | OPTS_TYPE_ST_ADDBITS15;
7198 kern_type = KERN_TYPE_SHA1_PWSLT;
7199 dgst_size = DGST_SIZE_4_5;
7200 parse_func = sha1b64s_parse_hash;
7201 sort_by_digest = sort_by_digest_4_5;
7202 opti_type = OPTI_TYPE_ZERO_BYTE
7203 | OPTI_TYPE_PRECOMPUTE_INIT
7204 | OPTI_TYPE_PRECOMPUTE_MERKLE
7205 | OPTI_TYPE_EARLY_SKIP
7206 | OPTI_TYPE_NOT_ITERATED
7207 | OPTI_TYPE_APPENDED_SALT
7208 | OPTI_TYPE_RAW_HASH;
7209 dgst_pos0 = 3;
7210 dgst_pos1 = 4;
7211 dgst_pos2 = 2;
7212 dgst_pos3 = 1;
7213 break;
7214
7215 case 112: hash_type = HASH_TYPE_SHA1;
7216 salt_type = SALT_TYPE_INTERN;
7217 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7218 opts_type = OPTS_TYPE_PT_GENERATE_BE
7219 | OPTS_TYPE_ST_ADD80
7220 | OPTS_TYPE_ST_ADDBITS15
7221 | OPTS_TYPE_ST_HEX;
7222 kern_type = KERN_TYPE_SHA1_PWSLT;
7223 dgst_size = DGST_SIZE_4_5;
7224 parse_func = oracles_parse_hash;
7225 sort_by_digest = sort_by_digest_4_5;
7226 opti_type = OPTI_TYPE_ZERO_BYTE
7227 | OPTI_TYPE_PRECOMPUTE_INIT
7228 | OPTI_TYPE_PRECOMPUTE_MERKLE
7229 | OPTI_TYPE_EARLY_SKIP
7230 | OPTI_TYPE_NOT_ITERATED
7231 | OPTI_TYPE_APPENDED_SALT
7232 | OPTI_TYPE_RAW_HASH;
7233 dgst_pos0 = 3;
7234 dgst_pos1 = 4;
7235 dgst_pos2 = 2;
7236 dgst_pos3 = 1;
7237 break;
7238
7239 case 120: hash_type = HASH_TYPE_SHA1;
7240 salt_type = SALT_TYPE_INTERN;
7241 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7242 opts_type = OPTS_TYPE_PT_GENERATE_BE
7243 | OPTS_TYPE_PT_ADD80
7244 | OPTS_TYPE_PT_ADDBITS15;
7245 kern_type = KERN_TYPE_SHA1_SLTPW;
7246 dgst_size = DGST_SIZE_4_5;
7247 parse_func = sha1s_parse_hash;
7248 sort_by_digest = sort_by_digest_4_5;
7249 opti_type = OPTI_TYPE_ZERO_BYTE
7250 | OPTI_TYPE_PRECOMPUTE_INIT
7251 | OPTI_TYPE_PRECOMPUTE_MERKLE
7252 | OPTI_TYPE_EARLY_SKIP
7253 | OPTI_TYPE_NOT_ITERATED
7254 | OPTI_TYPE_PREPENDED_SALT
7255 | OPTI_TYPE_RAW_HASH;
7256 dgst_pos0 = 3;
7257 dgst_pos1 = 4;
7258 dgst_pos2 = 2;
7259 dgst_pos3 = 1;
7260 break;
7261
7262 case 121: hash_type = HASH_TYPE_SHA1;
7263 salt_type = SALT_TYPE_INTERN;
7264 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7265 opts_type = OPTS_TYPE_PT_GENERATE_BE
7266 | OPTS_TYPE_PT_ADD80
7267 | OPTS_TYPE_PT_ADDBITS15
7268 | OPTS_TYPE_ST_LOWER;
7269 kern_type = KERN_TYPE_SHA1_SLTPW;
7270 dgst_size = DGST_SIZE_4_5;
7271 parse_func = smf_parse_hash;
7272 sort_by_digest = sort_by_digest_4_5;
7273 opti_type = OPTI_TYPE_ZERO_BYTE
7274 | OPTI_TYPE_PRECOMPUTE_INIT
7275 | OPTI_TYPE_PRECOMPUTE_MERKLE
7276 | OPTI_TYPE_EARLY_SKIP
7277 | OPTI_TYPE_NOT_ITERATED
7278 | OPTI_TYPE_PREPENDED_SALT
7279 | OPTI_TYPE_RAW_HASH;
7280 dgst_pos0 = 3;
7281 dgst_pos1 = 4;
7282 dgst_pos2 = 2;
7283 dgst_pos3 = 1;
7284 break;
7285
7286 case 122: hash_type = HASH_TYPE_SHA1;
7287 salt_type = SALT_TYPE_EMBEDDED;
7288 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7289 opts_type = OPTS_TYPE_PT_GENERATE_BE
7290 | OPTS_TYPE_PT_ADD80
7291 | OPTS_TYPE_PT_ADDBITS15
7292 | OPTS_TYPE_ST_HEX;
7293 kern_type = KERN_TYPE_SHA1_SLTPW;
7294 dgst_size = DGST_SIZE_4_5;
7295 parse_func = osx1_parse_hash;
7296 sort_by_digest = sort_by_digest_4_5;
7297 opti_type = OPTI_TYPE_ZERO_BYTE
7298 | OPTI_TYPE_PRECOMPUTE_INIT
7299 | OPTI_TYPE_PRECOMPUTE_MERKLE
7300 | OPTI_TYPE_EARLY_SKIP
7301 | OPTI_TYPE_NOT_ITERATED
7302 | OPTI_TYPE_PREPENDED_SALT
7303 | OPTI_TYPE_RAW_HASH;
7304 dgst_pos0 = 3;
7305 dgst_pos1 = 4;
7306 dgst_pos2 = 2;
7307 dgst_pos3 = 1;
7308 break;
7309
7310 case 124: hash_type = HASH_TYPE_SHA1;
7311 salt_type = SALT_TYPE_EMBEDDED;
7312 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7313 opts_type = OPTS_TYPE_PT_GENERATE_BE
7314 | OPTS_TYPE_PT_ADD80
7315 | OPTS_TYPE_PT_ADDBITS15;
7316 kern_type = KERN_TYPE_SHA1_SLTPW;
7317 dgst_size = DGST_SIZE_4_5;
7318 parse_func = djangosha1_parse_hash;
7319 sort_by_digest = sort_by_digest_4_5;
7320 opti_type = OPTI_TYPE_ZERO_BYTE
7321 | OPTI_TYPE_PRECOMPUTE_INIT
7322 | OPTI_TYPE_PRECOMPUTE_MERKLE
7323 | OPTI_TYPE_EARLY_SKIP
7324 | OPTI_TYPE_NOT_ITERATED
7325 | OPTI_TYPE_PREPENDED_SALT
7326 | OPTI_TYPE_RAW_HASH;
7327 dgst_pos0 = 3;
7328 dgst_pos1 = 4;
7329 dgst_pos2 = 2;
7330 dgst_pos3 = 1;
7331 break;
7332
7333 case 130: hash_type = HASH_TYPE_SHA1;
7334 salt_type = SALT_TYPE_INTERN;
7335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7336 opts_type = OPTS_TYPE_PT_GENERATE_BE
7337 | OPTS_TYPE_PT_UNICODE
7338 | OPTS_TYPE_ST_ADD80
7339 | OPTS_TYPE_ST_ADDBITS15;
7340 kern_type = KERN_TYPE_SHA1_PWUSLT;
7341 dgst_size = DGST_SIZE_4_5;
7342 parse_func = sha1s_parse_hash;
7343 sort_by_digest = sort_by_digest_4_5;
7344 opti_type = OPTI_TYPE_ZERO_BYTE
7345 | OPTI_TYPE_PRECOMPUTE_INIT
7346 | OPTI_TYPE_PRECOMPUTE_MERKLE
7347 | OPTI_TYPE_EARLY_SKIP
7348 | OPTI_TYPE_NOT_ITERATED
7349 | OPTI_TYPE_APPENDED_SALT
7350 | OPTI_TYPE_RAW_HASH;
7351 dgst_pos0 = 3;
7352 dgst_pos1 = 4;
7353 dgst_pos2 = 2;
7354 dgst_pos3 = 1;
7355 break;
7356
7357 case 131: hash_type = HASH_TYPE_SHA1;
7358 salt_type = SALT_TYPE_EMBEDDED;
7359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7360 opts_type = OPTS_TYPE_PT_GENERATE_BE
7361 | OPTS_TYPE_PT_UNICODE
7362 | OPTS_TYPE_PT_UPPER
7363 | OPTS_TYPE_ST_ADD80
7364 | OPTS_TYPE_ST_ADDBITS15
7365 | OPTS_TYPE_ST_HEX;
7366 kern_type = KERN_TYPE_SHA1_PWUSLT;
7367 dgst_size = DGST_SIZE_4_5;
7368 parse_func = mssql2000_parse_hash;
7369 sort_by_digest = sort_by_digest_4_5;
7370 opti_type = OPTI_TYPE_ZERO_BYTE
7371 | OPTI_TYPE_PRECOMPUTE_INIT
7372 | OPTI_TYPE_PRECOMPUTE_MERKLE
7373 | OPTI_TYPE_EARLY_SKIP
7374 | OPTI_TYPE_NOT_ITERATED
7375 | OPTI_TYPE_APPENDED_SALT
7376 | OPTI_TYPE_RAW_HASH;
7377 dgst_pos0 = 3;
7378 dgst_pos1 = 4;
7379 dgst_pos2 = 2;
7380 dgst_pos3 = 1;
7381 break;
7382
7383 case 132: hash_type = HASH_TYPE_SHA1;
7384 salt_type = SALT_TYPE_EMBEDDED;
7385 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7386 opts_type = OPTS_TYPE_PT_GENERATE_BE
7387 | OPTS_TYPE_PT_UNICODE
7388 | OPTS_TYPE_ST_ADD80
7389 | OPTS_TYPE_ST_ADDBITS15
7390 | OPTS_TYPE_ST_HEX;
7391 kern_type = KERN_TYPE_SHA1_PWUSLT;
7392 dgst_size = DGST_SIZE_4_5;
7393 parse_func = mssql2005_parse_hash;
7394 sort_by_digest = sort_by_digest_4_5;
7395 opti_type = OPTI_TYPE_ZERO_BYTE
7396 | OPTI_TYPE_PRECOMPUTE_INIT
7397 | OPTI_TYPE_PRECOMPUTE_MERKLE
7398 | OPTI_TYPE_EARLY_SKIP
7399 | OPTI_TYPE_NOT_ITERATED
7400 | OPTI_TYPE_APPENDED_SALT
7401 | OPTI_TYPE_RAW_HASH;
7402 dgst_pos0 = 3;
7403 dgst_pos1 = 4;
7404 dgst_pos2 = 2;
7405 dgst_pos3 = 1;
7406 break;
7407
7408 case 133: hash_type = HASH_TYPE_SHA1;
7409 salt_type = SALT_TYPE_EMBEDDED;
7410 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7411 opts_type = OPTS_TYPE_PT_GENERATE_BE
7412 | OPTS_TYPE_PT_UNICODE
7413 | OPTS_TYPE_ST_ADD80
7414 | OPTS_TYPE_ST_ADDBITS15;
7415 kern_type = KERN_TYPE_SHA1_PWUSLT;
7416 dgst_size = DGST_SIZE_4_5;
7417 parse_func = peoplesoft_parse_hash;
7418 sort_by_digest = sort_by_digest_4_5;
7419 opti_type = OPTI_TYPE_ZERO_BYTE
7420 | OPTI_TYPE_PRECOMPUTE_INIT
7421 | OPTI_TYPE_PRECOMPUTE_MERKLE
7422 | OPTI_TYPE_EARLY_SKIP
7423 | OPTI_TYPE_NOT_ITERATED
7424 | OPTI_TYPE_APPENDED_SALT
7425 | OPTI_TYPE_RAW_HASH;
7426 dgst_pos0 = 3;
7427 dgst_pos1 = 4;
7428 dgst_pos2 = 2;
7429 dgst_pos3 = 1;
7430 break;
7431
7432 case 140: hash_type = HASH_TYPE_SHA1;
7433 salt_type = SALT_TYPE_INTERN;
7434 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7435 opts_type = OPTS_TYPE_PT_GENERATE_BE
7436 | OPTS_TYPE_PT_ADD80
7437 | OPTS_TYPE_PT_ADDBITS15
7438 | OPTS_TYPE_PT_UNICODE;
7439 kern_type = KERN_TYPE_SHA1_SLTPWU;
7440 dgst_size = DGST_SIZE_4_5;
7441 parse_func = sha1s_parse_hash;
7442 sort_by_digest = sort_by_digest_4_5;
7443 opti_type = OPTI_TYPE_ZERO_BYTE
7444 | OPTI_TYPE_PRECOMPUTE_INIT
7445 | OPTI_TYPE_PRECOMPUTE_MERKLE
7446 | OPTI_TYPE_EARLY_SKIP
7447 | OPTI_TYPE_NOT_ITERATED
7448 | OPTI_TYPE_PREPENDED_SALT
7449 | OPTI_TYPE_RAW_HASH;
7450 dgst_pos0 = 3;
7451 dgst_pos1 = 4;
7452 dgst_pos2 = 2;
7453 dgst_pos3 = 1;
7454 break;
7455
7456 case 141: hash_type = HASH_TYPE_SHA1;
7457 salt_type = SALT_TYPE_EMBEDDED;
7458 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7459 opts_type = OPTS_TYPE_PT_GENERATE_BE
7460 | OPTS_TYPE_PT_ADD80
7461 | OPTS_TYPE_PT_ADDBITS15
7462 | OPTS_TYPE_PT_UNICODE
7463 | OPTS_TYPE_ST_BASE64;
7464 kern_type = KERN_TYPE_SHA1_SLTPWU;
7465 dgst_size = DGST_SIZE_4_5;
7466 parse_func = episerver_parse_hash;
7467 sort_by_digest = sort_by_digest_4_5;
7468 opti_type = OPTI_TYPE_ZERO_BYTE
7469 | OPTI_TYPE_PRECOMPUTE_INIT
7470 | OPTI_TYPE_PRECOMPUTE_MERKLE
7471 | OPTI_TYPE_EARLY_SKIP
7472 | OPTI_TYPE_NOT_ITERATED
7473 | OPTI_TYPE_PREPENDED_SALT
7474 | OPTI_TYPE_RAW_HASH;
7475 dgst_pos0 = 3;
7476 dgst_pos1 = 4;
7477 dgst_pos2 = 2;
7478 dgst_pos3 = 1;
7479 break;
7480
7481 case 150: hash_type = HASH_TYPE_SHA1;
7482 salt_type = SALT_TYPE_INTERN;
7483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7484 opts_type = OPTS_TYPE_PT_GENERATE_BE
7485 | OPTS_TYPE_ST_ADD80
7486 | OPTS_TYPE_ST_ADDBITS15;
7487 kern_type = KERN_TYPE_HMACSHA1_PW;
7488 dgst_size = DGST_SIZE_4_5;
7489 parse_func = hmacsha1_parse_hash;
7490 sort_by_digest = sort_by_digest_4_5;
7491 opti_type = OPTI_TYPE_ZERO_BYTE
7492 | OPTI_TYPE_NOT_ITERATED;
7493 dgst_pos0 = 3;
7494 dgst_pos1 = 4;
7495 dgst_pos2 = 2;
7496 dgst_pos3 = 1;
7497 break;
7498
7499 case 160: hash_type = HASH_TYPE_SHA1;
7500 salt_type = SALT_TYPE_INTERN;
7501 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7502 opts_type = OPTS_TYPE_PT_GENERATE_BE
7503 | OPTS_TYPE_PT_ADD80
7504 | OPTS_TYPE_PT_ADDBITS15;
7505 kern_type = KERN_TYPE_HMACSHA1_SLT;
7506 dgst_size = DGST_SIZE_4_5;
7507 parse_func = hmacsha1_parse_hash;
7508 sort_by_digest = sort_by_digest_4_5;
7509 opti_type = OPTI_TYPE_ZERO_BYTE
7510 | OPTI_TYPE_NOT_ITERATED;
7511 dgst_pos0 = 3;
7512 dgst_pos1 = 4;
7513 dgst_pos2 = 2;
7514 dgst_pos3 = 1;
7515 break;
7516
7517 case 190: hash_type = HASH_TYPE_SHA1;
7518 salt_type = SALT_TYPE_NONE;
7519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7520 opts_type = OPTS_TYPE_PT_GENERATE_BE
7521 | OPTS_TYPE_PT_ADD80
7522 | OPTS_TYPE_PT_ADDBITS15;
7523 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7524 dgst_size = DGST_SIZE_4_5;
7525 parse_func = sha1linkedin_parse_hash;
7526 sort_by_digest = sort_by_digest_4_5;
7527 opti_type = OPTI_TYPE_ZERO_BYTE
7528 | OPTI_TYPE_PRECOMPUTE_INIT
7529 | OPTI_TYPE_EARLY_SKIP
7530 | OPTI_TYPE_NOT_ITERATED
7531 | OPTI_TYPE_NOT_SALTED;
7532 dgst_pos0 = 0;
7533 dgst_pos1 = 4;
7534 dgst_pos2 = 3;
7535 dgst_pos3 = 2;
7536 break;
7537
7538 case 200: hash_type = HASH_TYPE_MYSQL;
7539 salt_type = SALT_TYPE_NONE;
7540 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7541 opts_type = 0;
7542 kern_type = KERN_TYPE_MYSQL;
7543 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7544 parse_func = mysql323_parse_hash;
7545 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7546 opti_type = OPTI_TYPE_ZERO_BYTE;
7547 dgst_pos0 = 0;
7548 dgst_pos1 = 1;
7549 dgst_pos2 = 2;
7550 dgst_pos3 = 3;
7551 break;
7552
7553 case 300: hash_type = HASH_TYPE_SHA1;
7554 salt_type = SALT_TYPE_NONE;
7555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7556 opts_type = OPTS_TYPE_PT_GENERATE_BE
7557 | OPTS_TYPE_PT_ADD80
7558 | OPTS_TYPE_PT_ADDBITS15;
7559 kern_type = KERN_TYPE_MYSQL41;
7560 dgst_size = DGST_SIZE_4_5;
7561 parse_func = sha1_parse_hash;
7562 sort_by_digest = sort_by_digest_4_5;
7563 opti_type = OPTI_TYPE_ZERO_BYTE
7564 | OPTI_TYPE_PRECOMPUTE_INIT
7565 | OPTI_TYPE_PRECOMPUTE_MERKLE
7566 | OPTI_TYPE_EARLY_SKIP
7567 | OPTI_TYPE_NOT_ITERATED
7568 | OPTI_TYPE_NOT_SALTED;
7569 dgst_pos0 = 3;
7570 dgst_pos1 = 4;
7571 dgst_pos2 = 2;
7572 dgst_pos3 = 1;
7573 break;
7574
7575 case 400: hash_type = HASH_TYPE_MD5;
7576 salt_type = SALT_TYPE_EMBEDDED;
7577 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7578 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7579 kern_type = KERN_TYPE_PHPASS;
7580 dgst_size = DGST_SIZE_4_4;
7581 parse_func = phpass_parse_hash;
7582 sort_by_digest = sort_by_digest_4_4;
7583 opti_type = OPTI_TYPE_ZERO_BYTE;
7584 dgst_pos0 = 0;
7585 dgst_pos1 = 1;
7586 dgst_pos2 = 2;
7587 dgst_pos3 = 3;
7588 break;
7589
7590 case 500: hash_type = HASH_TYPE_MD5;
7591 salt_type = SALT_TYPE_EMBEDDED;
7592 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7593 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7594 kern_type = KERN_TYPE_MD5CRYPT;
7595 dgst_size = DGST_SIZE_4_4;
7596 parse_func = md5crypt_parse_hash;
7597 sort_by_digest = sort_by_digest_4_4;
7598 opti_type = OPTI_TYPE_ZERO_BYTE;
7599 dgst_pos0 = 0;
7600 dgst_pos1 = 1;
7601 dgst_pos2 = 2;
7602 dgst_pos3 = 3;
7603 break;
7604
7605 case 501: hash_type = HASH_TYPE_MD5;
7606 salt_type = SALT_TYPE_EMBEDDED;
7607 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7608 opts_type = OPTS_TYPE_PT_GENERATE_LE
7609 | OPTS_TYPE_HASH_COPY;
7610 kern_type = KERN_TYPE_MD5CRYPT;
7611 dgst_size = DGST_SIZE_4_4;
7612 parse_func = juniper_parse_hash;
7613 sort_by_digest = sort_by_digest_4_4;
7614 opti_type = OPTI_TYPE_ZERO_BYTE;
7615 dgst_pos0 = 0;
7616 dgst_pos1 = 1;
7617 dgst_pos2 = 2;
7618 dgst_pos3 = 3;
7619 break;
7620
7621 case 900: hash_type = HASH_TYPE_MD4;
7622 salt_type = SALT_TYPE_NONE;
7623 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7624 opts_type = OPTS_TYPE_PT_GENERATE_LE
7625 | OPTS_TYPE_PT_ADD80
7626 | OPTS_TYPE_PT_ADDBITS14;
7627 kern_type = KERN_TYPE_MD4;
7628 dgst_size = DGST_SIZE_4_4;
7629 parse_func = md4_parse_hash;
7630 sort_by_digest = sort_by_digest_4_4;
7631 opti_type = OPTI_TYPE_ZERO_BYTE
7632 | OPTI_TYPE_PRECOMPUTE_INIT
7633 | OPTI_TYPE_PRECOMPUTE_MERKLE
7634 | OPTI_TYPE_MEET_IN_MIDDLE
7635 | OPTI_TYPE_EARLY_SKIP
7636 | OPTI_TYPE_NOT_ITERATED
7637 | OPTI_TYPE_NOT_SALTED
7638 | OPTI_TYPE_RAW_HASH;
7639 dgst_pos0 = 0;
7640 dgst_pos1 = 3;
7641 dgst_pos2 = 2;
7642 dgst_pos3 = 1;
7643 break;
7644
7645 case 1000: hash_type = HASH_TYPE_MD4;
7646 salt_type = SALT_TYPE_NONE;
7647 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7648 opts_type = OPTS_TYPE_PT_GENERATE_LE
7649 | OPTS_TYPE_PT_ADD80
7650 | OPTS_TYPE_PT_ADDBITS14
7651 | OPTS_TYPE_PT_UNICODE;
7652 kern_type = KERN_TYPE_MD4_PWU;
7653 dgst_size = DGST_SIZE_4_4;
7654 parse_func = md4_parse_hash;
7655 sort_by_digest = sort_by_digest_4_4;
7656 opti_type = OPTI_TYPE_ZERO_BYTE
7657 | OPTI_TYPE_PRECOMPUTE_INIT
7658 | OPTI_TYPE_PRECOMPUTE_MERKLE
7659 | OPTI_TYPE_MEET_IN_MIDDLE
7660 | OPTI_TYPE_EARLY_SKIP
7661 | OPTI_TYPE_NOT_ITERATED
7662 | OPTI_TYPE_NOT_SALTED
7663 | OPTI_TYPE_RAW_HASH;
7664 dgst_pos0 = 0;
7665 dgst_pos1 = 3;
7666 dgst_pos2 = 2;
7667 dgst_pos3 = 1;
7668 break;
7669
7670 case 1100: hash_type = HASH_TYPE_MD4;
7671 salt_type = SALT_TYPE_INTERN;
7672 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7673 opts_type = OPTS_TYPE_PT_GENERATE_LE
7674 | OPTS_TYPE_PT_ADD80
7675 | OPTS_TYPE_PT_ADDBITS14
7676 | OPTS_TYPE_PT_UNICODE
7677 | OPTS_TYPE_ST_ADD80
7678 | OPTS_TYPE_ST_UNICODE
7679 | OPTS_TYPE_ST_LOWER;
7680 kern_type = KERN_TYPE_MD44_PWUSLT;
7681 dgst_size = DGST_SIZE_4_4;
7682 parse_func = dcc_parse_hash;
7683 sort_by_digest = sort_by_digest_4_4;
7684 opti_type = OPTI_TYPE_ZERO_BYTE
7685 | OPTI_TYPE_PRECOMPUTE_INIT
7686 | OPTI_TYPE_PRECOMPUTE_MERKLE
7687 | OPTI_TYPE_EARLY_SKIP
7688 | OPTI_TYPE_NOT_ITERATED;
7689 dgst_pos0 = 0;
7690 dgst_pos1 = 3;
7691 dgst_pos2 = 2;
7692 dgst_pos3 = 1;
7693 break;
7694
7695 case 1400: hash_type = HASH_TYPE_SHA256;
7696 salt_type = SALT_TYPE_NONE;
7697 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7698 opts_type = OPTS_TYPE_PT_GENERATE_BE
7699 | OPTS_TYPE_PT_ADD80
7700 | OPTS_TYPE_PT_ADDBITS15;
7701 kern_type = KERN_TYPE_SHA256;
7702 dgst_size = DGST_SIZE_4_8;
7703 parse_func = sha256_parse_hash;
7704 sort_by_digest = sort_by_digest_4_8;
7705 opti_type = OPTI_TYPE_ZERO_BYTE
7706 | OPTI_TYPE_PRECOMPUTE_INIT
7707 | OPTI_TYPE_PRECOMPUTE_MERKLE
7708 | OPTI_TYPE_EARLY_SKIP
7709 | OPTI_TYPE_NOT_ITERATED
7710 | OPTI_TYPE_NOT_SALTED
7711 | OPTI_TYPE_RAW_HASH;
7712 dgst_pos0 = 3;
7713 dgst_pos1 = 7;
7714 dgst_pos2 = 2;
7715 dgst_pos3 = 6;
7716 break;
7717
7718 case 1410: hash_type = HASH_TYPE_SHA256;
7719 salt_type = SALT_TYPE_INTERN;
7720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7721 opts_type = OPTS_TYPE_PT_GENERATE_BE
7722 | OPTS_TYPE_ST_ADD80
7723 | OPTS_TYPE_ST_ADDBITS15;
7724 kern_type = KERN_TYPE_SHA256_PWSLT;
7725 dgst_size = DGST_SIZE_4_8;
7726 parse_func = sha256s_parse_hash;
7727 sort_by_digest = sort_by_digest_4_8;
7728 opti_type = OPTI_TYPE_ZERO_BYTE
7729 | OPTI_TYPE_PRECOMPUTE_INIT
7730 | OPTI_TYPE_PRECOMPUTE_MERKLE
7731 | OPTI_TYPE_EARLY_SKIP
7732 | OPTI_TYPE_NOT_ITERATED
7733 | OPTI_TYPE_APPENDED_SALT
7734 | OPTI_TYPE_RAW_HASH;
7735 dgst_pos0 = 3;
7736 dgst_pos1 = 7;
7737 dgst_pos2 = 2;
7738 dgst_pos3 = 6;
7739 break;
7740
7741 case 1420: hash_type = HASH_TYPE_SHA256;
7742 salt_type = SALT_TYPE_INTERN;
7743 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7744 opts_type = OPTS_TYPE_PT_GENERATE_BE
7745 | OPTS_TYPE_PT_ADD80
7746 | OPTS_TYPE_PT_ADDBITS15;
7747 kern_type = KERN_TYPE_SHA256_SLTPW;
7748 dgst_size = DGST_SIZE_4_8;
7749 parse_func = sha256s_parse_hash;
7750 sort_by_digest = sort_by_digest_4_8;
7751 opti_type = OPTI_TYPE_ZERO_BYTE
7752 | OPTI_TYPE_PRECOMPUTE_INIT
7753 | OPTI_TYPE_PRECOMPUTE_MERKLE
7754 | OPTI_TYPE_EARLY_SKIP
7755 | OPTI_TYPE_NOT_ITERATED
7756 | OPTI_TYPE_PREPENDED_SALT
7757 | OPTI_TYPE_RAW_HASH;
7758 dgst_pos0 = 3;
7759 dgst_pos1 = 7;
7760 dgst_pos2 = 2;
7761 dgst_pos3 = 6;
7762 break;
7763
7764 case 1421: hash_type = HASH_TYPE_SHA256;
7765 salt_type = SALT_TYPE_EMBEDDED;
7766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7767 opts_type = OPTS_TYPE_PT_GENERATE_BE
7768 | OPTS_TYPE_PT_ADD80
7769 | OPTS_TYPE_PT_ADDBITS15;
7770 kern_type = KERN_TYPE_SHA256_SLTPW;
7771 dgst_size = DGST_SIZE_4_8;
7772 parse_func = hmailserver_parse_hash;
7773 sort_by_digest = sort_by_digest_4_8;
7774 opti_type = OPTI_TYPE_ZERO_BYTE
7775 | OPTI_TYPE_PRECOMPUTE_INIT
7776 | OPTI_TYPE_PRECOMPUTE_MERKLE
7777 | OPTI_TYPE_EARLY_SKIP
7778 | OPTI_TYPE_NOT_ITERATED
7779 | OPTI_TYPE_PREPENDED_SALT
7780 | OPTI_TYPE_RAW_HASH;
7781 dgst_pos0 = 3;
7782 dgst_pos1 = 7;
7783 dgst_pos2 = 2;
7784 dgst_pos3 = 6;
7785 break;
7786
7787 case 1430: hash_type = HASH_TYPE_SHA256;
7788 salt_type = SALT_TYPE_INTERN;
7789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7790 opts_type = OPTS_TYPE_PT_GENERATE_BE
7791 | OPTS_TYPE_PT_UNICODE
7792 | OPTS_TYPE_ST_ADD80
7793 | OPTS_TYPE_ST_ADDBITS15;
7794 kern_type = KERN_TYPE_SHA256_PWUSLT;
7795 dgst_size = DGST_SIZE_4_8;
7796 parse_func = sha256s_parse_hash;
7797 sort_by_digest = sort_by_digest_4_8;
7798 opti_type = OPTI_TYPE_ZERO_BYTE
7799 | OPTI_TYPE_PRECOMPUTE_INIT
7800 | OPTI_TYPE_PRECOMPUTE_MERKLE
7801 | OPTI_TYPE_EARLY_SKIP
7802 | OPTI_TYPE_NOT_ITERATED
7803 | OPTI_TYPE_APPENDED_SALT
7804 | OPTI_TYPE_RAW_HASH;
7805 dgst_pos0 = 3;
7806 dgst_pos1 = 7;
7807 dgst_pos2 = 2;
7808 dgst_pos3 = 6;
7809 break;
7810
7811 case 1440: hash_type = HASH_TYPE_SHA256;
7812 salt_type = SALT_TYPE_INTERN;
7813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7814 opts_type = OPTS_TYPE_PT_GENERATE_BE
7815 | OPTS_TYPE_PT_ADD80
7816 | OPTS_TYPE_PT_ADDBITS15
7817 | OPTS_TYPE_PT_UNICODE;
7818 kern_type = KERN_TYPE_SHA256_SLTPWU;
7819 dgst_size = DGST_SIZE_4_8;
7820 parse_func = sha256s_parse_hash;
7821 sort_by_digest = sort_by_digest_4_8;
7822 opti_type = OPTI_TYPE_ZERO_BYTE
7823 | OPTI_TYPE_PRECOMPUTE_INIT
7824 | OPTI_TYPE_PRECOMPUTE_MERKLE
7825 | OPTI_TYPE_EARLY_SKIP
7826 | OPTI_TYPE_NOT_ITERATED
7827 | OPTI_TYPE_PREPENDED_SALT
7828 | OPTI_TYPE_RAW_HASH;
7829 dgst_pos0 = 3;
7830 dgst_pos1 = 7;
7831 dgst_pos2 = 2;
7832 dgst_pos3 = 6;
7833 break;
7834
7835 case 1441: hash_type = HASH_TYPE_SHA256;
7836 salt_type = SALT_TYPE_EMBEDDED;
7837 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7838 opts_type = OPTS_TYPE_PT_GENERATE_BE
7839 | OPTS_TYPE_PT_ADD80
7840 | OPTS_TYPE_PT_ADDBITS15
7841 | OPTS_TYPE_PT_UNICODE
7842 | OPTS_TYPE_ST_BASE64;
7843 kern_type = KERN_TYPE_SHA256_SLTPWU;
7844 dgst_size = DGST_SIZE_4_8;
7845 parse_func = episerver4_parse_hash;
7846 sort_by_digest = sort_by_digest_4_8;
7847 opti_type = OPTI_TYPE_ZERO_BYTE
7848 | OPTI_TYPE_PRECOMPUTE_INIT
7849 | OPTI_TYPE_PRECOMPUTE_MERKLE
7850 | OPTI_TYPE_EARLY_SKIP
7851 | OPTI_TYPE_NOT_ITERATED
7852 | OPTI_TYPE_PREPENDED_SALT
7853 | OPTI_TYPE_RAW_HASH;
7854 dgst_pos0 = 3;
7855 dgst_pos1 = 7;
7856 dgst_pos2 = 2;
7857 dgst_pos3 = 6;
7858 break;
7859
7860 case 1450: hash_type = HASH_TYPE_SHA256;
7861 salt_type = SALT_TYPE_INTERN;
7862 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7863 opts_type = OPTS_TYPE_PT_GENERATE_BE
7864 | OPTS_TYPE_ST_ADD80;
7865 kern_type = KERN_TYPE_HMACSHA256_PW;
7866 dgst_size = DGST_SIZE_4_8;
7867 parse_func = hmacsha256_parse_hash;
7868 sort_by_digest = sort_by_digest_4_8;
7869 opti_type = OPTI_TYPE_ZERO_BYTE
7870 | OPTI_TYPE_NOT_ITERATED;
7871 dgst_pos0 = 3;
7872 dgst_pos1 = 7;
7873 dgst_pos2 = 2;
7874 dgst_pos3 = 6;
7875 break;
7876
7877 case 1460: hash_type = HASH_TYPE_SHA256;
7878 salt_type = SALT_TYPE_INTERN;
7879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7880 opts_type = OPTS_TYPE_PT_GENERATE_BE
7881 | OPTS_TYPE_PT_ADD80
7882 | OPTS_TYPE_PT_ADDBITS15;
7883 kern_type = KERN_TYPE_HMACSHA256_SLT;
7884 dgst_size = DGST_SIZE_4_8;
7885 parse_func = hmacsha256_parse_hash;
7886 sort_by_digest = sort_by_digest_4_8;
7887 opti_type = OPTI_TYPE_ZERO_BYTE
7888 | OPTI_TYPE_NOT_ITERATED;
7889 dgst_pos0 = 3;
7890 dgst_pos1 = 7;
7891 dgst_pos2 = 2;
7892 dgst_pos3 = 6;
7893 break;
7894
7895 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7896 salt_type = SALT_TYPE_EMBEDDED;
7897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7898 opts_type = OPTS_TYPE_PT_GENERATE_LE
7899 | OPTS_TYPE_PT_BITSLICE;
7900 kern_type = KERN_TYPE_DESCRYPT;
7901 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7902 parse_func = descrypt_parse_hash;
7903 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7904 opti_type = OPTI_TYPE_ZERO_BYTE
7905 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7906 dgst_pos0 = 0;
7907 dgst_pos1 = 1;
7908 dgst_pos2 = 2;
7909 dgst_pos3 = 3;
7910 break;
7911
7912 case 1600: hash_type = HASH_TYPE_MD5;
7913 salt_type = SALT_TYPE_EMBEDDED;
7914 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7915 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7916 kern_type = KERN_TYPE_APR1CRYPT;
7917 dgst_size = DGST_SIZE_4_4;
7918 parse_func = md5apr1_parse_hash;
7919 sort_by_digest = sort_by_digest_4_4;
7920 opti_type = OPTI_TYPE_ZERO_BYTE;
7921 dgst_pos0 = 0;
7922 dgst_pos1 = 1;
7923 dgst_pos2 = 2;
7924 dgst_pos3 = 3;
7925 break;
7926
7927 case 1700: hash_type = HASH_TYPE_SHA512;
7928 salt_type = SALT_TYPE_NONE;
7929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7930 opts_type = OPTS_TYPE_PT_GENERATE_BE
7931 | OPTS_TYPE_PT_ADD80
7932 | OPTS_TYPE_PT_ADDBITS15;
7933 kern_type = KERN_TYPE_SHA512;
7934 dgst_size = DGST_SIZE_8_8;
7935 parse_func = sha512_parse_hash;
7936 sort_by_digest = sort_by_digest_8_8;
7937 opti_type = OPTI_TYPE_ZERO_BYTE
7938 | OPTI_TYPE_PRECOMPUTE_INIT
7939 | OPTI_TYPE_PRECOMPUTE_MERKLE
7940 | OPTI_TYPE_EARLY_SKIP
7941 | OPTI_TYPE_NOT_ITERATED
7942 | OPTI_TYPE_NOT_SALTED
7943 | OPTI_TYPE_USES_BITS_64
7944 | OPTI_TYPE_RAW_HASH;
7945 dgst_pos0 = 14;
7946 dgst_pos1 = 15;
7947 dgst_pos2 = 6;
7948 dgst_pos3 = 7;
7949 break;
7950
7951 case 1710: hash_type = HASH_TYPE_SHA512;
7952 salt_type = SALT_TYPE_INTERN;
7953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7954 opts_type = OPTS_TYPE_PT_GENERATE_BE
7955 | OPTS_TYPE_ST_ADD80
7956 | OPTS_TYPE_ST_ADDBITS15;
7957 kern_type = KERN_TYPE_SHA512_PWSLT;
7958 dgst_size = DGST_SIZE_8_8;
7959 parse_func = sha512s_parse_hash;
7960 sort_by_digest = sort_by_digest_8_8;
7961 opti_type = OPTI_TYPE_ZERO_BYTE
7962 | OPTI_TYPE_PRECOMPUTE_INIT
7963 | OPTI_TYPE_PRECOMPUTE_MERKLE
7964 | OPTI_TYPE_EARLY_SKIP
7965 | OPTI_TYPE_NOT_ITERATED
7966 | OPTI_TYPE_APPENDED_SALT
7967 | OPTI_TYPE_USES_BITS_64
7968 | OPTI_TYPE_RAW_HASH;
7969 dgst_pos0 = 14;
7970 dgst_pos1 = 15;
7971 dgst_pos2 = 6;
7972 dgst_pos3 = 7;
7973 break;
7974
7975 case 1711: hash_type = HASH_TYPE_SHA512;
7976 salt_type = SALT_TYPE_EMBEDDED;
7977 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7978 opts_type = OPTS_TYPE_PT_GENERATE_BE
7979 | OPTS_TYPE_ST_ADD80
7980 | OPTS_TYPE_ST_ADDBITS15;
7981 kern_type = KERN_TYPE_SHA512_PWSLT;
7982 dgst_size = DGST_SIZE_8_8;
7983 parse_func = sha512b64s_parse_hash;
7984 sort_by_digest = sort_by_digest_8_8;
7985 opti_type = OPTI_TYPE_ZERO_BYTE
7986 | OPTI_TYPE_PRECOMPUTE_INIT
7987 | OPTI_TYPE_PRECOMPUTE_MERKLE
7988 | OPTI_TYPE_EARLY_SKIP
7989 | OPTI_TYPE_NOT_ITERATED
7990 | OPTI_TYPE_APPENDED_SALT
7991 | OPTI_TYPE_USES_BITS_64
7992 | OPTI_TYPE_RAW_HASH;
7993 dgst_pos0 = 14;
7994 dgst_pos1 = 15;
7995 dgst_pos2 = 6;
7996 dgst_pos3 = 7;
7997 break;
7998
7999 case 1720: hash_type = HASH_TYPE_SHA512;
8000 salt_type = SALT_TYPE_INTERN;
8001 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8002 opts_type = OPTS_TYPE_PT_GENERATE_BE
8003 | OPTS_TYPE_PT_ADD80
8004 | OPTS_TYPE_PT_ADDBITS15;
8005 kern_type = KERN_TYPE_SHA512_SLTPW;
8006 dgst_size = DGST_SIZE_8_8;
8007 parse_func = sha512s_parse_hash;
8008 sort_by_digest = sort_by_digest_8_8;
8009 opti_type = OPTI_TYPE_ZERO_BYTE
8010 | OPTI_TYPE_PRECOMPUTE_INIT
8011 | OPTI_TYPE_PRECOMPUTE_MERKLE
8012 | OPTI_TYPE_EARLY_SKIP
8013 | OPTI_TYPE_NOT_ITERATED
8014 | OPTI_TYPE_PREPENDED_SALT
8015 | OPTI_TYPE_USES_BITS_64
8016 | OPTI_TYPE_RAW_HASH;
8017 dgst_pos0 = 14;
8018 dgst_pos1 = 15;
8019 dgst_pos2 = 6;
8020 dgst_pos3 = 7;
8021 break;
8022
8023 case 1722: hash_type = HASH_TYPE_SHA512;
8024 salt_type = SALT_TYPE_EMBEDDED;
8025 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8026 opts_type = OPTS_TYPE_PT_GENERATE_BE
8027 | OPTS_TYPE_PT_ADD80
8028 | OPTS_TYPE_PT_ADDBITS15
8029 | OPTS_TYPE_ST_HEX;
8030 kern_type = KERN_TYPE_SHA512_SLTPW;
8031 dgst_size = DGST_SIZE_8_8;
8032 parse_func = osx512_parse_hash;
8033 sort_by_digest = sort_by_digest_8_8;
8034 opti_type = OPTI_TYPE_ZERO_BYTE
8035 | OPTI_TYPE_PRECOMPUTE_INIT
8036 | OPTI_TYPE_PRECOMPUTE_MERKLE
8037 | OPTI_TYPE_EARLY_SKIP
8038 | OPTI_TYPE_NOT_ITERATED
8039 | OPTI_TYPE_PREPENDED_SALT
8040 | OPTI_TYPE_USES_BITS_64
8041 | OPTI_TYPE_RAW_HASH;
8042 dgst_pos0 = 14;
8043 dgst_pos1 = 15;
8044 dgst_pos2 = 6;
8045 dgst_pos3 = 7;
8046 break;
8047
8048 case 1730: hash_type = HASH_TYPE_SHA512;
8049 salt_type = SALT_TYPE_INTERN;
8050 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8051 opts_type = OPTS_TYPE_PT_GENERATE_BE
8052 | OPTS_TYPE_PT_UNICODE
8053 | OPTS_TYPE_ST_ADD80
8054 | OPTS_TYPE_ST_ADDBITS15;
8055 kern_type = KERN_TYPE_SHA512_PWSLTU;
8056 dgst_size = DGST_SIZE_8_8;
8057 parse_func = sha512s_parse_hash;
8058 sort_by_digest = sort_by_digest_8_8;
8059 opti_type = OPTI_TYPE_ZERO_BYTE
8060 | OPTI_TYPE_PRECOMPUTE_INIT
8061 | OPTI_TYPE_PRECOMPUTE_MERKLE
8062 | OPTI_TYPE_EARLY_SKIP
8063 | OPTI_TYPE_NOT_ITERATED
8064 | OPTI_TYPE_APPENDED_SALT
8065 | OPTI_TYPE_USES_BITS_64
8066 | OPTI_TYPE_RAW_HASH;
8067 dgst_pos0 = 14;
8068 dgst_pos1 = 15;
8069 dgst_pos2 = 6;
8070 dgst_pos3 = 7;
8071 break;
8072
8073 case 1731: hash_type = HASH_TYPE_SHA512;
8074 salt_type = SALT_TYPE_EMBEDDED;
8075 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8076 opts_type = OPTS_TYPE_PT_GENERATE_BE
8077 | OPTS_TYPE_PT_UNICODE
8078 | OPTS_TYPE_ST_ADD80
8079 | OPTS_TYPE_ST_ADDBITS15
8080 | OPTS_TYPE_ST_HEX;
8081 kern_type = KERN_TYPE_SHA512_PWSLTU;
8082 dgst_size = DGST_SIZE_8_8;
8083 parse_func = mssql2012_parse_hash;
8084 sort_by_digest = sort_by_digest_8_8;
8085 opti_type = OPTI_TYPE_ZERO_BYTE
8086 | OPTI_TYPE_PRECOMPUTE_INIT
8087 | OPTI_TYPE_PRECOMPUTE_MERKLE
8088 | OPTI_TYPE_EARLY_SKIP
8089 | OPTI_TYPE_NOT_ITERATED
8090 | OPTI_TYPE_APPENDED_SALT
8091 | OPTI_TYPE_USES_BITS_64
8092 | OPTI_TYPE_RAW_HASH;
8093 dgst_pos0 = 14;
8094 dgst_pos1 = 15;
8095 dgst_pos2 = 6;
8096 dgst_pos3 = 7;
8097 break;
8098
8099 case 1740: hash_type = HASH_TYPE_SHA512;
8100 salt_type = SALT_TYPE_INTERN;
8101 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8102 opts_type = OPTS_TYPE_PT_GENERATE_BE
8103 | OPTS_TYPE_PT_ADD80
8104 | OPTS_TYPE_PT_ADDBITS15
8105 | OPTS_TYPE_PT_UNICODE;
8106 kern_type = KERN_TYPE_SHA512_SLTPWU;
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_PREPENDED_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 1750: hash_type = HASH_TYPE_SHA512;
8125 salt_type = SALT_TYPE_INTERN;
8126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8127 opts_type = OPTS_TYPE_PT_GENERATE_BE
8128 | OPTS_TYPE_ST_ADD80;
8129 kern_type = KERN_TYPE_HMACSHA512_PW;
8130 dgst_size = DGST_SIZE_8_8;
8131 parse_func = hmacsha512_parse_hash;
8132 sort_by_digest = sort_by_digest_8_8;
8133 opti_type = OPTI_TYPE_ZERO_BYTE
8134 | OPTI_TYPE_USES_BITS_64
8135 | OPTI_TYPE_NOT_ITERATED;
8136 dgst_pos0 = 14;
8137 dgst_pos1 = 15;
8138 dgst_pos2 = 6;
8139 dgst_pos3 = 7;
8140 break;
8141
8142 case 1760: hash_type = HASH_TYPE_SHA512;
8143 salt_type = SALT_TYPE_INTERN;
8144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8145 opts_type = OPTS_TYPE_PT_GENERATE_BE
8146 | OPTS_TYPE_PT_ADD80
8147 | OPTS_TYPE_PT_ADDBITS15;
8148 kern_type = KERN_TYPE_HMACSHA512_SLT;
8149 dgst_size = DGST_SIZE_8_8;
8150 parse_func = hmacsha512_parse_hash;
8151 sort_by_digest = sort_by_digest_8_8;
8152 opti_type = OPTI_TYPE_ZERO_BYTE
8153 | OPTI_TYPE_USES_BITS_64
8154 | OPTI_TYPE_NOT_ITERATED;
8155 dgst_pos0 = 14;
8156 dgst_pos1 = 15;
8157 dgst_pos2 = 6;
8158 dgst_pos3 = 7;
8159 break;
8160
8161 case 1800: hash_type = HASH_TYPE_SHA512;
8162 salt_type = SALT_TYPE_EMBEDDED;
8163 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8164 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8165 kern_type = KERN_TYPE_SHA512CRYPT;
8166 dgst_size = DGST_SIZE_8_8;
8167 parse_func = sha512crypt_parse_hash;
8168 sort_by_digest = sort_by_digest_8_8;
8169 opti_type = OPTI_TYPE_ZERO_BYTE
8170 | OPTI_TYPE_USES_BITS_64;
8171 dgst_pos0 = 0;
8172 dgst_pos1 = 1;
8173 dgst_pos2 = 2;
8174 dgst_pos3 = 3;
8175 break;
8176
8177 case 2100: hash_type = HASH_TYPE_DCC2;
8178 salt_type = SALT_TYPE_EMBEDDED;
8179 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8180 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8181 | OPTS_TYPE_ST_LOWER
8182 | OPTS_TYPE_ST_UNICODE;
8183 kern_type = KERN_TYPE_DCC2;
8184 dgst_size = DGST_SIZE_4_4;
8185 parse_func = dcc2_parse_hash;
8186 sort_by_digest = sort_by_digest_4_4;
8187 opti_type = OPTI_TYPE_ZERO_BYTE;
8188 dgst_pos0 = 0;
8189 dgst_pos1 = 1;
8190 dgst_pos2 = 2;
8191 dgst_pos3 = 3;
8192 break;
8193
8194 case 2400: hash_type = HASH_TYPE_MD5;
8195 salt_type = SALT_TYPE_NONE;
8196 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8197 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8198 kern_type = KERN_TYPE_MD5PIX;
8199 dgst_size = DGST_SIZE_4_4;
8200 parse_func = md5pix_parse_hash;
8201 sort_by_digest = sort_by_digest_4_4;
8202 opti_type = OPTI_TYPE_ZERO_BYTE
8203 | OPTI_TYPE_PRECOMPUTE_INIT
8204 | OPTI_TYPE_PRECOMPUTE_MERKLE
8205 | OPTI_TYPE_EARLY_SKIP
8206 | OPTI_TYPE_NOT_ITERATED
8207 | OPTI_TYPE_NOT_SALTED;
8208 dgst_pos0 = 0;
8209 dgst_pos1 = 3;
8210 dgst_pos2 = 2;
8211 dgst_pos3 = 1;
8212 break;
8213
8214 case 2410: hash_type = HASH_TYPE_MD5;
8215 salt_type = SALT_TYPE_INTERN;
8216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8217 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8218 kern_type = KERN_TYPE_MD5ASA;
8219 dgst_size = DGST_SIZE_4_4;
8220 parse_func = md5asa_parse_hash;
8221 sort_by_digest = sort_by_digest_4_4;
8222 opti_type = OPTI_TYPE_ZERO_BYTE
8223 | OPTI_TYPE_PRECOMPUTE_INIT
8224 | OPTI_TYPE_PRECOMPUTE_MERKLE
8225 | OPTI_TYPE_EARLY_SKIP
8226 | OPTI_TYPE_NOT_ITERATED;
8227 dgst_pos0 = 0;
8228 dgst_pos1 = 3;
8229 dgst_pos2 = 2;
8230 dgst_pos3 = 1;
8231 break;
8232
8233 case 2500: hash_type = HASH_TYPE_WPA;
8234 salt_type = SALT_TYPE_EMBEDDED;
8235 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8236 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8237 kern_type = KERN_TYPE_WPA;
8238 dgst_size = DGST_SIZE_4_4;
8239 parse_func = wpa_parse_hash;
8240 sort_by_digest = sort_by_digest_4_4;
8241 opti_type = OPTI_TYPE_ZERO_BYTE;
8242 dgst_pos0 = 0;
8243 dgst_pos1 = 1;
8244 dgst_pos2 = 2;
8245 dgst_pos3 = 3;
8246 break;
8247
8248 case 2600: hash_type = HASH_TYPE_MD5;
8249 salt_type = SALT_TYPE_VIRTUAL;
8250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8251 opts_type = OPTS_TYPE_PT_GENERATE_LE
8252 | OPTS_TYPE_PT_ADD80
8253 | OPTS_TYPE_PT_ADDBITS14
8254 | OPTS_TYPE_ST_ADD80;
8255 kern_type = KERN_TYPE_MD55_PWSLT1;
8256 dgst_size = DGST_SIZE_4_4;
8257 parse_func = md5md5_parse_hash;
8258 sort_by_digest = sort_by_digest_4_4;
8259 opti_type = OPTI_TYPE_ZERO_BYTE
8260 | OPTI_TYPE_PRECOMPUTE_INIT
8261 | OPTI_TYPE_PRECOMPUTE_MERKLE
8262 | OPTI_TYPE_EARLY_SKIP;
8263 dgst_pos0 = 0;
8264 dgst_pos1 = 3;
8265 dgst_pos2 = 2;
8266 dgst_pos3 = 1;
8267 break;
8268
8269 case 2611: hash_type = HASH_TYPE_MD5;
8270 salt_type = SALT_TYPE_INTERN;
8271 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8272 opts_type = OPTS_TYPE_PT_GENERATE_LE
8273 | OPTS_TYPE_PT_ADD80
8274 | OPTS_TYPE_PT_ADDBITS14
8275 | OPTS_TYPE_ST_ADD80;
8276 kern_type = KERN_TYPE_MD55_PWSLT1;
8277 dgst_size = DGST_SIZE_4_4;
8278 parse_func = vb3_parse_hash;
8279 sort_by_digest = sort_by_digest_4_4;
8280 opti_type = OPTI_TYPE_ZERO_BYTE
8281 | OPTI_TYPE_PRECOMPUTE_INIT
8282 | OPTI_TYPE_PRECOMPUTE_MERKLE
8283 | OPTI_TYPE_EARLY_SKIP;
8284 dgst_pos0 = 0;
8285 dgst_pos1 = 3;
8286 dgst_pos2 = 2;
8287 dgst_pos3 = 1;
8288 break;
8289
8290 case 2612: hash_type = HASH_TYPE_MD5;
8291 salt_type = SALT_TYPE_EMBEDDED;
8292 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8293 opts_type = OPTS_TYPE_PT_GENERATE_LE
8294 | OPTS_TYPE_PT_ADD80
8295 | OPTS_TYPE_PT_ADDBITS14
8296 | OPTS_TYPE_ST_ADD80
8297 | OPTS_TYPE_ST_HEX;
8298 kern_type = KERN_TYPE_MD55_PWSLT1;
8299 dgst_size = DGST_SIZE_4_4;
8300 parse_func = phps_parse_hash;
8301 sort_by_digest = sort_by_digest_4_4;
8302 opti_type = OPTI_TYPE_ZERO_BYTE
8303 | OPTI_TYPE_PRECOMPUTE_INIT
8304 | OPTI_TYPE_PRECOMPUTE_MERKLE
8305 | OPTI_TYPE_EARLY_SKIP;
8306 dgst_pos0 = 0;
8307 dgst_pos1 = 3;
8308 dgst_pos2 = 2;
8309 dgst_pos3 = 1;
8310 break;
8311
8312 case 2711: hash_type = HASH_TYPE_MD5;
8313 salt_type = SALT_TYPE_INTERN;
8314 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8315 opts_type = OPTS_TYPE_PT_GENERATE_LE
8316 | OPTS_TYPE_PT_ADD80
8317 | OPTS_TYPE_PT_ADDBITS14
8318 | OPTS_TYPE_ST_ADD80;
8319 kern_type = KERN_TYPE_MD55_PWSLT2;
8320 dgst_size = DGST_SIZE_4_4;
8321 parse_func = vb30_parse_hash;
8322 sort_by_digest = sort_by_digest_4_4;
8323 opti_type = OPTI_TYPE_ZERO_BYTE
8324 | OPTI_TYPE_PRECOMPUTE_INIT
8325 | OPTI_TYPE_EARLY_SKIP;
8326 dgst_pos0 = 0;
8327 dgst_pos1 = 3;
8328 dgst_pos2 = 2;
8329 dgst_pos3 = 1;
8330 break;
8331
8332 case 2811: hash_type = HASH_TYPE_MD5;
8333 salt_type = SALT_TYPE_INTERN;
8334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8335 opts_type = OPTS_TYPE_PT_GENERATE_LE
8336 | OPTS_TYPE_PT_ADD80
8337 | OPTS_TYPE_PT_ADDBITS14;
8338 kern_type = KERN_TYPE_MD55_SLTPW;
8339 dgst_size = DGST_SIZE_4_4;
8340 parse_func = ipb2_parse_hash;
8341 sort_by_digest = sort_by_digest_4_4;
8342 opti_type = OPTI_TYPE_ZERO_BYTE
8343 | OPTI_TYPE_PRECOMPUTE_INIT
8344 | OPTI_TYPE_EARLY_SKIP;
8345 dgst_pos0 = 0;
8346 dgst_pos1 = 3;
8347 dgst_pos2 = 2;
8348 dgst_pos3 = 1;
8349 break;
8350
8351 case 3000: hash_type = HASH_TYPE_LM;
8352 salt_type = SALT_TYPE_NONE;
8353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8354 opts_type = OPTS_TYPE_PT_GENERATE_LE
8355 | OPTS_TYPE_PT_UPPER
8356 | OPTS_TYPE_PT_BITSLICE;
8357 kern_type = KERN_TYPE_LM;
8358 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8359 parse_func = lm_parse_hash;
8360 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8361 opti_type = OPTI_TYPE_ZERO_BYTE
8362 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8363 dgst_pos0 = 0;
8364 dgst_pos1 = 1;
8365 dgst_pos2 = 2;
8366 dgst_pos3 = 3;
8367 break;
8368
8369 case 3100: hash_type = HASH_TYPE_ORACLEH;
8370 salt_type = SALT_TYPE_INTERN;
8371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8372 opts_type = OPTS_TYPE_PT_GENERATE_LE
8373 | OPTS_TYPE_PT_UPPER
8374 | OPTS_TYPE_ST_UPPER;
8375 kern_type = KERN_TYPE_ORACLEH;
8376 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8377 parse_func = oracleh_parse_hash;
8378 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8379 opti_type = OPTI_TYPE_ZERO_BYTE;
8380 dgst_pos0 = 0;
8381 dgst_pos1 = 1;
8382 dgst_pos2 = 2;
8383 dgst_pos3 = 3;
8384 break;
8385
8386 case 3200: hash_type = HASH_TYPE_BCRYPT;
8387 salt_type = SALT_TYPE_EMBEDDED;
8388 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8389 opts_type = OPTS_TYPE_PT_GENERATE_LE
8390 | OPTS_TYPE_ST_GENERATE_LE;
8391 kern_type = KERN_TYPE_BCRYPT;
8392 dgst_size = DGST_SIZE_4_6;
8393 parse_func = bcrypt_parse_hash;
8394 sort_by_digest = sort_by_digest_4_6;
8395 opti_type = OPTI_TYPE_ZERO_BYTE;
8396 dgst_pos0 = 0;
8397 dgst_pos1 = 1;
8398 dgst_pos2 = 2;
8399 dgst_pos3 = 3;
8400 break;
8401
8402 case 3710: hash_type = HASH_TYPE_MD5;
8403 salt_type = SALT_TYPE_INTERN;
8404 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8405 opts_type = OPTS_TYPE_PT_GENERATE_LE
8406 | OPTS_TYPE_PT_ADD80
8407 | OPTS_TYPE_PT_ADDBITS14;
8408 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8409 dgst_size = DGST_SIZE_4_4;
8410 parse_func = md5s_parse_hash;
8411 sort_by_digest = sort_by_digest_4_4;
8412 opti_type = OPTI_TYPE_ZERO_BYTE
8413 | OPTI_TYPE_PRECOMPUTE_INIT
8414 | OPTI_TYPE_PRECOMPUTE_MERKLE
8415 | OPTI_TYPE_EARLY_SKIP;
8416 dgst_pos0 = 0;
8417 dgst_pos1 = 3;
8418 dgst_pos2 = 2;
8419 dgst_pos3 = 1;
8420 break;
8421
8422 case 3711: hash_type = HASH_TYPE_MD5;
8423 salt_type = SALT_TYPE_EMBEDDED;
8424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8425 opts_type = OPTS_TYPE_PT_GENERATE_LE
8426 | OPTS_TYPE_PT_ADD80
8427 | OPTS_TYPE_PT_ADDBITS14;
8428 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8429 dgst_size = DGST_SIZE_4_4;
8430 parse_func = mediawiki_b_parse_hash;
8431 sort_by_digest = sort_by_digest_4_4;
8432 opti_type = OPTI_TYPE_ZERO_BYTE
8433 | OPTI_TYPE_PRECOMPUTE_INIT
8434 | OPTI_TYPE_PRECOMPUTE_MERKLE
8435 | OPTI_TYPE_EARLY_SKIP;
8436 dgst_pos0 = 0;
8437 dgst_pos1 = 3;
8438 dgst_pos2 = 2;
8439 dgst_pos3 = 1;
8440 break;
8441
8442 case 3800: hash_type = HASH_TYPE_MD5;
8443 salt_type = SALT_TYPE_INTERN;
8444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8445 opts_type = OPTS_TYPE_PT_GENERATE_LE
8446 | OPTS_TYPE_ST_ADDBITS14;
8447 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8448 dgst_size = DGST_SIZE_4_4;
8449 parse_func = md5s_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 | OPTI_TYPE_NOT_ITERATED
8456 | OPTI_TYPE_RAW_HASH;
8457 dgst_pos0 = 0;
8458 dgst_pos1 = 3;
8459 dgst_pos2 = 2;
8460 dgst_pos3 = 1;
8461 break;
8462
8463 case 4300: hash_type = HASH_TYPE_MD5;
8464 salt_type = SALT_TYPE_VIRTUAL;
8465 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8466 opts_type = OPTS_TYPE_PT_GENERATE_LE
8467 | OPTS_TYPE_PT_ADD80
8468 | OPTS_TYPE_PT_ADDBITS14
8469 | OPTS_TYPE_ST_ADD80;
8470 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8471 dgst_size = DGST_SIZE_4_4;
8472 parse_func = md5md5_parse_hash;
8473 sort_by_digest = sort_by_digest_4_4;
8474 opti_type = OPTI_TYPE_ZERO_BYTE
8475 | OPTI_TYPE_PRECOMPUTE_INIT
8476 | OPTI_TYPE_PRECOMPUTE_MERKLE
8477 | OPTI_TYPE_EARLY_SKIP;
8478 dgst_pos0 = 0;
8479 dgst_pos1 = 3;
8480 dgst_pos2 = 2;
8481 dgst_pos3 = 1;
8482 break;
8483
8484
8485 case 4400: hash_type = HASH_TYPE_MD5;
8486 salt_type = SALT_TYPE_NONE;
8487 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8488 opts_type = OPTS_TYPE_PT_GENERATE_BE
8489 | OPTS_TYPE_PT_ADD80
8490 | OPTS_TYPE_PT_ADDBITS15;
8491 kern_type = KERN_TYPE_MD5_SHA1;
8492 dgst_size = DGST_SIZE_4_4;
8493 parse_func = md5_parse_hash;
8494 sort_by_digest = sort_by_digest_4_4;
8495 opti_type = OPTI_TYPE_ZERO_BYTE
8496 | OPTI_TYPE_PRECOMPUTE_INIT
8497 | OPTI_TYPE_PRECOMPUTE_MERKLE
8498 | OPTI_TYPE_EARLY_SKIP
8499 | OPTI_TYPE_NOT_ITERATED
8500 | OPTI_TYPE_NOT_SALTED
8501 | OPTI_TYPE_RAW_HASH;
8502 dgst_pos0 = 0;
8503 dgst_pos1 = 3;
8504 dgst_pos2 = 2;
8505 dgst_pos3 = 1;
8506 break;
8507
8508 case 4500: hash_type = HASH_TYPE_SHA1;
8509 salt_type = SALT_TYPE_NONE;
8510 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8511 opts_type = OPTS_TYPE_PT_GENERATE_BE
8512 | OPTS_TYPE_PT_ADD80
8513 | OPTS_TYPE_PT_ADDBITS15;
8514 kern_type = KERN_TYPE_SHA11;
8515 dgst_size = DGST_SIZE_4_5;
8516 parse_func = sha1_parse_hash;
8517 sort_by_digest = sort_by_digest_4_5;
8518 opti_type = OPTI_TYPE_ZERO_BYTE
8519 | OPTI_TYPE_PRECOMPUTE_INIT
8520 | OPTI_TYPE_PRECOMPUTE_MERKLE
8521 | OPTI_TYPE_EARLY_SKIP
8522 | OPTI_TYPE_NOT_SALTED;
8523 dgst_pos0 = 3;
8524 dgst_pos1 = 4;
8525 dgst_pos2 = 2;
8526 dgst_pos3 = 1;
8527 break;
8528
8529 case 4700: hash_type = HASH_TYPE_SHA1;
8530 salt_type = SALT_TYPE_NONE;
8531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8532 opts_type = OPTS_TYPE_PT_GENERATE_LE
8533 | OPTS_TYPE_PT_ADD80
8534 | OPTS_TYPE_PT_ADDBITS14;
8535 kern_type = KERN_TYPE_SHA1_MD5;
8536 dgst_size = DGST_SIZE_4_5;
8537 parse_func = sha1_parse_hash;
8538 sort_by_digest = sort_by_digest_4_5;
8539 opti_type = OPTI_TYPE_ZERO_BYTE
8540 | OPTI_TYPE_PRECOMPUTE_INIT
8541 | OPTI_TYPE_PRECOMPUTE_MERKLE
8542 | OPTI_TYPE_EARLY_SKIP
8543 | OPTI_TYPE_NOT_ITERATED
8544 | OPTI_TYPE_NOT_SALTED
8545 | OPTI_TYPE_RAW_HASH;
8546 dgst_pos0 = 3;
8547 dgst_pos1 = 4;
8548 dgst_pos2 = 2;
8549 dgst_pos3 = 1;
8550 break;
8551
8552 case 4800: hash_type = HASH_TYPE_MD5;
8553 salt_type = SALT_TYPE_EMBEDDED;
8554 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8555 opts_type = OPTS_TYPE_PT_GENERATE_LE
8556 | OPTS_TYPE_PT_ADDBITS14;
8557 kern_type = KERN_TYPE_MD5_CHAP;
8558 dgst_size = DGST_SIZE_4_4;
8559 parse_func = chap_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_MEET_IN_MIDDLE
8565 | OPTI_TYPE_EARLY_SKIP
8566 | OPTI_TYPE_NOT_ITERATED
8567 | OPTI_TYPE_RAW_HASH;
8568 dgst_pos0 = 0;
8569 dgst_pos1 = 3;
8570 dgst_pos2 = 2;
8571 dgst_pos3 = 1;
8572 break;
8573
8574 case 4900: hash_type = HASH_TYPE_SHA1;
8575 salt_type = SALT_TYPE_INTERN;
8576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8577 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8578 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8579 dgst_size = DGST_SIZE_4_5;
8580 parse_func = sha1s_parse_hash;
8581 sort_by_digest = sort_by_digest_4_5;
8582 opti_type = OPTI_TYPE_ZERO_BYTE
8583 | OPTI_TYPE_PRECOMPUTE_INIT
8584 | OPTI_TYPE_PRECOMPUTE_MERKLE
8585 | OPTI_TYPE_EARLY_SKIP;
8586 dgst_pos0 = 3;
8587 dgst_pos1 = 4;
8588 dgst_pos2 = 2;
8589 dgst_pos3 = 1;
8590 break;
8591
8592 case 5000: hash_type = HASH_TYPE_KECCAK;
8593 salt_type = SALT_TYPE_EMBEDDED;
8594 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8595 opts_type = OPTS_TYPE_PT_GENERATE_LE
8596 | OPTS_TYPE_PT_ADD01;
8597 kern_type = KERN_TYPE_KECCAK;
8598 dgst_size = DGST_SIZE_8_25;
8599 parse_func = keccak_parse_hash;
8600 sort_by_digest = sort_by_digest_8_25;
8601 opti_type = OPTI_TYPE_ZERO_BYTE
8602 | OPTI_TYPE_USES_BITS_64
8603 | OPTI_TYPE_RAW_HASH;
8604 dgst_pos0 = 2;
8605 dgst_pos1 = 3;
8606 dgst_pos2 = 4;
8607 dgst_pos3 = 5;
8608 break;
8609
8610 case 5100: hash_type = HASH_TYPE_MD5H;
8611 salt_type = SALT_TYPE_NONE;
8612 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8613 opts_type = OPTS_TYPE_PT_GENERATE_LE
8614 | OPTS_TYPE_PT_ADD80
8615 | OPTS_TYPE_PT_ADDBITS14;
8616 kern_type = KERN_TYPE_MD5H;
8617 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8618 parse_func = md5half_parse_hash;
8619 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8620 opti_type = OPTI_TYPE_ZERO_BYTE
8621 | OPTI_TYPE_RAW_HASH;
8622 dgst_pos0 = 0;
8623 dgst_pos1 = 1;
8624 dgst_pos2 = 2;
8625 dgst_pos3 = 3;
8626 break;
8627
8628 case 5200: hash_type = HASH_TYPE_SHA256;
8629 salt_type = SALT_TYPE_EMBEDDED;
8630 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8631 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8632 kern_type = KERN_TYPE_PSAFE3;
8633 dgst_size = DGST_SIZE_4_8;
8634 parse_func = psafe3_parse_hash;
8635 sort_by_digest = sort_by_digest_4_8;
8636 opti_type = OPTI_TYPE_ZERO_BYTE;
8637 dgst_pos0 = 0;
8638 dgst_pos1 = 1;
8639 dgst_pos2 = 2;
8640 dgst_pos3 = 3;
8641 break;
8642
8643 case 5300: hash_type = HASH_TYPE_MD5;
8644 salt_type = SALT_TYPE_EMBEDDED;
8645 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8646 opts_type = OPTS_TYPE_PT_GENERATE_LE
8647 | OPTS_TYPE_ST_ADD80;
8648 kern_type = KERN_TYPE_IKEPSK_MD5;
8649 dgst_size = DGST_SIZE_4_4;
8650 parse_func = ikepsk_md5_parse_hash;
8651 sort_by_digest = sort_by_digest_4_4;
8652 opti_type = OPTI_TYPE_ZERO_BYTE;
8653 dgst_pos0 = 0;
8654 dgst_pos1 = 3;
8655 dgst_pos2 = 2;
8656 dgst_pos3 = 1;
8657 break;
8658
8659 case 5400: hash_type = HASH_TYPE_SHA1;
8660 salt_type = SALT_TYPE_EMBEDDED;
8661 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8662 opts_type = OPTS_TYPE_PT_GENERATE_BE
8663 | OPTS_TYPE_ST_ADD80;
8664 kern_type = KERN_TYPE_IKEPSK_SHA1;
8665 dgst_size = DGST_SIZE_4_5;
8666 parse_func = ikepsk_sha1_parse_hash;
8667 sort_by_digest = sort_by_digest_4_5;
8668 opti_type = OPTI_TYPE_ZERO_BYTE;
8669 dgst_pos0 = 3;
8670 dgst_pos1 = 4;
8671 dgst_pos2 = 2;
8672 dgst_pos3 = 1;
8673 break;
8674
8675 case 5500: hash_type = HASH_TYPE_NETNTLM;
8676 salt_type = SALT_TYPE_EMBEDDED;
8677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8678 opts_type = OPTS_TYPE_PT_GENERATE_LE
8679 | OPTS_TYPE_PT_ADD80
8680 | OPTS_TYPE_PT_ADDBITS14
8681 | OPTS_TYPE_PT_UNICODE
8682 | OPTS_TYPE_ST_HEX;
8683 kern_type = KERN_TYPE_NETNTLMv1;
8684 dgst_size = DGST_SIZE_4_4;
8685 parse_func = netntlmv1_parse_hash;
8686 sort_by_digest = sort_by_digest_4_4;
8687 opti_type = OPTI_TYPE_ZERO_BYTE
8688 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8689 dgst_pos0 = 0;
8690 dgst_pos1 = 1;
8691 dgst_pos2 = 2;
8692 dgst_pos3 = 3;
8693 break;
8694
8695 case 5600: hash_type = HASH_TYPE_MD5;
8696 salt_type = SALT_TYPE_EMBEDDED;
8697 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8698 opts_type = OPTS_TYPE_PT_GENERATE_LE
8699 | OPTS_TYPE_PT_ADD80
8700 | OPTS_TYPE_PT_ADDBITS14
8701 | OPTS_TYPE_PT_UNICODE;
8702 kern_type = KERN_TYPE_NETNTLMv2;
8703 dgst_size = DGST_SIZE_4_4;
8704 parse_func = netntlmv2_parse_hash;
8705 sort_by_digest = sort_by_digest_4_4;
8706 opti_type = OPTI_TYPE_ZERO_BYTE;
8707 dgst_pos0 = 0;
8708 dgst_pos1 = 3;
8709 dgst_pos2 = 2;
8710 dgst_pos3 = 1;
8711 break;
8712
8713 case 5700: hash_type = HASH_TYPE_SHA256;
8714 salt_type = SALT_TYPE_NONE;
8715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8716 opts_type = OPTS_TYPE_PT_GENERATE_BE
8717 | OPTS_TYPE_PT_ADD80
8718 | OPTS_TYPE_PT_ADDBITS15;
8719 kern_type = KERN_TYPE_SHA256;
8720 dgst_size = DGST_SIZE_4_8;
8721 parse_func = cisco4_parse_hash;
8722 sort_by_digest = sort_by_digest_4_8;
8723 opti_type = OPTI_TYPE_ZERO_BYTE
8724 | OPTI_TYPE_PRECOMPUTE_INIT
8725 | OPTI_TYPE_PRECOMPUTE_MERKLE
8726 | OPTI_TYPE_EARLY_SKIP
8727 | OPTI_TYPE_NOT_ITERATED
8728 | OPTI_TYPE_NOT_SALTED
8729 | OPTI_TYPE_RAW_HASH;
8730 dgst_pos0 = 3;
8731 dgst_pos1 = 7;
8732 dgst_pos2 = 2;
8733 dgst_pos3 = 6;
8734 break;
8735
8736 case 5800: hash_type = HASH_TYPE_SHA1;
8737 salt_type = SALT_TYPE_INTERN;
8738 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8739 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8740 | OPTS_TYPE_ST_ADD80;
8741 kern_type = KERN_TYPE_ANDROIDPIN;
8742 dgst_size = DGST_SIZE_4_5;
8743 parse_func = androidpin_parse_hash;
8744 sort_by_digest = sort_by_digest_4_5;
8745 opti_type = OPTI_TYPE_ZERO_BYTE;
8746 dgst_pos0 = 0;
8747 dgst_pos1 = 1;
8748 dgst_pos2 = 2;
8749 dgst_pos3 = 3;
8750 break;
8751
8752 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8753 salt_type = SALT_TYPE_NONE;
8754 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8755 opts_type = OPTS_TYPE_PT_GENERATE_LE
8756 | OPTS_TYPE_PT_ADD80;
8757 kern_type = KERN_TYPE_RIPEMD160;
8758 dgst_size = DGST_SIZE_4_5;
8759 parse_func = ripemd160_parse_hash;
8760 sort_by_digest = sort_by_digest_4_5;
8761 opti_type = OPTI_TYPE_ZERO_BYTE;
8762 dgst_pos0 = 0;
8763 dgst_pos1 = 1;
8764 dgst_pos2 = 2;
8765 dgst_pos3 = 3;
8766 break;
8767
8768 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8769 salt_type = SALT_TYPE_NONE;
8770 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8771 opts_type = OPTS_TYPE_PT_GENERATE_BE
8772 | OPTS_TYPE_PT_ADD80;
8773 kern_type = KERN_TYPE_WHIRLPOOL;
8774 dgst_size = DGST_SIZE_4_16;
8775 parse_func = whirlpool_parse_hash;
8776 sort_by_digest = sort_by_digest_4_16;
8777 opti_type = OPTI_TYPE_ZERO_BYTE;
8778 dgst_pos0 = 0;
8779 dgst_pos1 = 1;
8780 dgst_pos2 = 2;
8781 dgst_pos3 = 3;
8782 break;
8783
8784 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8785 salt_type = SALT_TYPE_EMBEDDED;
8786 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8787 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8788 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8789 dgst_size = DGST_SIZE_4_5;
8790 parse_func = truecrypt_parse_hash_2k;
8791 sort_by_digest = sort_by_digest_4_5;
8792 opti_type = OPTI_TYPE_ZERO_BYTE;
8793 dgst_pos0 = 0;
8794 dgst_pos1 = 1;
8795 dgst_pos2 = 2;
8796 dgst_pos3 = 3;
8797 break;
8798
8799 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8800 salt_type = SALT_TYPE_EMBEDDED;
8801 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8802 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8803 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8804 dgst_size = DGST_SIZE_4_5;
8805 parse_func = truecrypt_parse_hash_2k;
8806 sort_by_digest = sort_by_digest_4_5;
8807 opti_type = OPTI_TYPE_ZERO_BYTE;
8808 dgst_pos0 = 0;
8809 dgst_pos1 = 1;
8810 dgst_pos2 = 2;
8811 dgst_pos3 = 3;
8812 break;
8813
8814 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8815 salt_type = SALT_TYPE_EMBEDDED;
8816 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8817 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8818 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8819 dgst_size = DGST_SIZE_4_5;
8820 parse_func = truecrypt_parse_hash_2k;
8821 sort_by_digest = sort_by_digest_4_5;
8822 opti_type = OPTI_TYPE_ZERO_BYTE;
8823 dgst_pos0 = 0;
8824 dgst_pos1 = 1;
8825 dgst_pos2 = 2;
8826 dgst_pos3 = 3;
8827 break;
8828
8829 case 6221: hash_type = HASH_TYPE_SHA512;
8830 salt_type = SALT_TYPE_EMBEDDED;
8831 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8832 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8833 kern_type = KERN_TYPE_TCSHA512_XTS512;
8834 dgst_size = DGST_SIZE_8_8;
8835 parse_func = truecrypt_parse_hash_1k;
8836 sort_by_digest = sort_by_digest_8_8;
8837 opti_type = OPTI_TYPE_ZERO_BYTE
8838 | OPTI_TYPE_USES_BITS_64;
8839 dgst_pos0 = 0;
8840 dgst_pos1 = 1;
8841 dgst_pos2 = 2;
8842 dgst_pos3 = 3;
8843 break;
8844
8845 case 6222: hash_type = HASH_TYPE_SHA512;
8846 salt_type = SALT_TYPE_EMBEDDED;
8847 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8848 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8849 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8850 dgst_size = DGST_SIZE_8_8;
8851 parse_func = truecrypt_parse_hash_1k;
8852 sort_by_digest = sort_by_digest_8_8;
8853 opti_type = OPTI_TYPE_ZERO_BYTE
8854 | OPTI_TYPE_USES_BITS_64;
8855 dgst_pos0 = 0;
8856 dgst_pos1 = 1;
8857 dgst_pos2 = 2;
8858 dgst_pos3 = 3;
8859 break;
8860
8861 case 6223: hash_type = HASH_TYPE_SHA512;
8862 salt_type = SALT_TYPE_EMBEDDED;
8863 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8864 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8865 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8866 dgst_size = DGST_SIZE_8_8;
8867 parse_func = truecrypt_parse_hash_1k;
8868 sort_by_digest = sort_by_digest_8_8;
8869 opti_type = OPTI_TYPE_ZERO_BYTE
8870 | OPTI_TYPE_USES_BITS_64;
8871 dgst_pos0 = 0;
8872 dgst_pos1 = 1;
8873 dgst_pos2 = 2;
8874 dgst_pos3 = 3;
8875 break;
8876
8877 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8878 salt_type = SALT_TYPE_EMBEDDED;
8879 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8880 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8881 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8882 dgst_size = DGST_SIZE_4_8;
8883 parse_func = truecrypt_parse_hash_1k;
8884 sort_by_digest = sort_by_digest_4_8;
8885 opti_type = OPTI_TYPE_ZERO_BYTE;
8886 dgst_pos0 = 0;
8887 dgst_pos1 = 1;
8888 dgst_pos2 = 2;
8889 dgst_pos3 = 3;
8890 break;
8891
8892 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8893 salt_type = SALT_TYPE_EMBEDDED;
8894 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8895 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8896 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8897 dgst_size = DGST_SIZE_4_8;
8898 parse_func = truecrypt_parse_hash_1k;
8899 sort_by_digest = sort_by_digest_4_8;
8900 opti_type = OPTI_TYPE_ZERO_BYTE;
8901 dgst_pos0 = 0;
8902 dgst_pos1 = 1;
8903 dgst_pos2 = 2;
8904 dgst_pos3 = 3;
8905 break;
8906
8907 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8908 salt_type = SALT_TYPE_EMBEDDED;
8909 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8910 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8911 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8912 dgst_size = DGST_SIZE_4_8;
8913 parse_func = truecrypt_parse_hash_1k;
8914 sort_by_digest = sort_by_digest_4_8;
8915 opti_type = OPTI_TYPE_ZERO_BYTE;
8916 dgst_pos0 = 0;
8917 dgst_pos1 = 1;
8918 dgst_pos2 = 2;
8919 dgst_pos3 = 3;
8920 break;
8921
8922 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8923 salt_type = SALT_TYPE_EMBEDDED;
8924 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8925 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8926 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8927 dgst_size = DGST_SIZE_4_5;
8928 parse_func = truecrypt_parse_hash_1k;
8929 sort_by_digest = sort_by_digest_4_5;
8930 opti_type = OPTI_TYPE_ZERO_BYTE;
8931 dgst_pos0 = 0;
8932 dgst_pos1 = 1;
8933 dgst_pos2 = 2;
8934 dgst_pos3 = 3;
8935 break;
8936
8937 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8938 salt_type = SALT_TYPE_EMBEDDED;
8939 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8940 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8941 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8942 dgst_size = DGST_SIZE_4_5;
8943 parse_func = truecrypt_parse_hash_1k;
8944 sort_by_digest = sort_by_digest_4_5;
8945 opti_type = OPTI_TYPE_ZERO_BYTE;
8946 dgst_pos0 = 0;
8947 dgst_pos1 = 1;
8948 dgst_pos2 = 2;
8949 dgst_pos3 = 3;
8950 break;
8951
8952 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8953 salt_type = SALT_TYPE_EMBEDDED;
8954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8955 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8956 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8957 dgst_size = DGST_SIZE_4_5;
8958 parse_func = truecrypt_parse_hash_1k;
8959 sort_by_digest = sort_by_digest_4_5;
8960 opti_type = OPTI_TYPE_ZERO_BYTE;
8961 dgst_pos0 = 0;
8962 dgst_pos1 = 1;
8963 dgst_pos2 = 2;
8964 dgst_pos3 = 3;
8965 break;
8966
8967 case 6300: hash_type = HASH_TYPE_MD5;
8968 salt_type = SALT_TYPE_EMBEDDED;
8969 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8970 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8971 kern_type = KERN_TYPE_MD5AIX;
8972 dgst_size = DGST_SIZE_4_4;
8973 parse_func = md5aix_parse_hash;
8974 sort_by_digest = sort_by_digest_4_4;
8975 opti_type = OPTI_TYPE_ZERO_BYTE;
8976 dgst_pos0 = 0;
8977 dgst_pos1 = 1;
8978 dgst_pos2 = 2;
8979 dgst_pos3 = 3;
8980 break;
8981
8982 case 6400: hash_type = HASH_TYPE_SHA256;
8983 salt_type = SALT_TYPE_EMBEDDED;
8984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8985 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8986 kern_type = KERN_TYPE_SHA256AIX;
8987 dgst_size = DGST_SIZE_4_8;
8988 parse_func = sha256aix_parse_hash;
8989 sort_by_digest = sort_by_digest_4_8;
8990 opti_type = OPTI_TYPE_ZERO_BYTE;
8991 dgst_pos0 = 0;
8992 dgst_pos1 = 1;
8993 dgst_pos2 = 2;
8994 dgst_pos3 = 3;
8995 break;
8996
8997 case 6500: hash_type = HASH_TYPE_SHA512;
8998 salt_type = SALT_TYPE_EMBEDDED;
8999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9000 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9001 kern_type = KERN_TYPE_SHA512AIX;
9002 dgst_size = DGST_SIZE_8_8;
9003 parse_func = sha512aix_parse_hash;
9004 sort_by_digest = sort_by_digest_8_8;
9005 opti_type = OPTI_TYPE_ZERO_BYTE
9006 | OPTI_TYPE_USES_BITS_64;
9007 dgst_pos0 = 0;
9008 dgst_pos1 = 1;
9009 dgst_pos2 = 2;
9010 dgst_pos3 = 3;
9011 break;
9012
9013 case 6600: hash_type = HASH_TYPE_AES;
9014 salt_type = SALT_TYPE_EMBEDDED;
9015 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9016 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9017 kern_type = KERN_TYPE_AGILEKEY;
9018 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9019 parse_func = agilekey_parse_hash;
9020 sort_by_digest = sort_by_digest_4_5;
9021 opti_type = OPTI_TYPE_ZERO_BYTE;
9022 dgst_pos0 = 0;
9023 dgst_pos1 = 1;
9024 dgst_pos2 = 2;
9025 dgst_pos3 = 3;
9026 break;
9027
9028 case 6700: hash_type = HASH_TYPE_SHA1;
9029 salt_type = SALT_TYPE_EMBEDDED;
9030 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9031 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9032 kern_type = KERN_TYPE_SHA1AIX;
9033 dgst_size = DGST_SIZE_4_5;
9034 parse_func = sha1aix_parse_hash;
9035 sort_by_digest = sort_by_digest_4_5;
9036 opti_type = OPTI_TYPE_ZERO_BYTE;
9037 dgst_pos0 = 0;
9038 dgst_pos1 = 1;
9039 dgst_pos2 = 2;
9040 dgst_pos3 = 3;
9041 break;
9042
9043 case 6800: hash_type = HASH_TYPE_AES;
9044 salt_type = SALT_TYPE_EMBEDDED;
9045 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9046 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9047 kern_type = KERN_TYPE_LASTPASS;
9048 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9049 parse_func = lastpass_parse_hash;
9050 sort_by_digest = sort_by_digest_4_8;
9051 opti_type = OPTI_TYPE_ZERO_BYTE;
9052 dgst_pos0 = 0;
9053 dgst_pos1 = 1;
9054 dgst_pos2 = 2;
9055 dgst_pos3 = 3;
9056 break;
9057
9058 case 6900: hash_type = HASH_TYPE_GOST;
9059 salt_type = SALT_TYPE_NONE;
9060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9061 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9062 kern_type = KERN_TYPE_GOST;
9063 dgst_size = DGST_SIZE_4_8;
9064 parse_func = gost_parse_hash;
9065 sort_by_digest = sort_by_digest_4_8;
9066 opti_type = OPTI_TYPE_ZERO_BYTE;
9067 dgst_pos0 = 0;
9068 dgst_pos1 = 1;
9069 dgst_pos2 = 2;
9070 dgst_pos3 = 3;
9071 break;
9072
9073 case 7100: hash_type = HASH_TYPE_SHA512;
9074 salt_type = SALT_TYPE_EMBEDDED;
9075 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9076 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9077 kern_type = KERN_TYPE_PBKDF2_SHA512;
9078 dgst_size = DGST_SIZE_8_16;
9079 parse_func = sha512osx_parse_hash;
9080 sort_by_digest = sort_by_digest_8_16;
9081 opti_type = OPTI_TYPE_ZERO_BYTE
9082 | OPTI_TYPE_USES_BITS_64;
9083 dgst_pos0 = 0;
9084 dgst_pos1 = 1;
9085 dgst_pos2 = 2;
9086 dgst_pos3 = 3;
9087 break;
9088
9089 case 7200: hash_type = HASH_TYPE_SHA512;
9090 salt_type = SALT_TYPE_EMBEDDED;
9091 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9092 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9093 kern_type = KERN_TYPE_PBKDF2_SHA512;
9094 dgst_size = DGST_SIZE_8_16;
9095 parse_func = sha512grub_parse_hash;
9096 sort_by_digest = sort_by_digest_8_16;
9097 opti_type = OPTI_TYPE_ZERO_BYTE
9098 | OPTI_TYPE_USES_BITS_64;
9099 dgst_pos0 = 0;
9100 dgst_pos1 = 1;
9101 dgst_pos2 = 2;
9102 dgst_pos3 = 3;
9103 break;
9104
9105 case 7300: hash_type = HASH_TYPE_SHA1;
9106 salt_type = SALT_TYPE_EMBEDDED;
9107 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9108 opts_type = OPTS_TYPE_PT_GENERATE_BE
9109 | OPTS_TYPE_ST_ADD80
9110 | OPTS_TYPE_ST_ADDBITS15;
9111 kern_type = KERN_TYPE_RAKP;
9112 dgst_size = DGST_SIZE_4_5;
9113 parse_func = rakp_parse_hash;
9114 sort_by_digest = sort_by_digest_4_5;
9115 opti_type = OPTI_TYPE_ZERO_BYTE
9116 | OPTI_TYPE_NOT_ITERATED;
9117 dgst_pos0 = 3;
9118 dgst_pos1 = 4;
9119 dgst_pos2 = 2;
9120 dgst_pos3 = 1;
9121 break;
9122
9123 case 7400: hash_type = HASH_TYPE_SHA256;
9124 salt_type = SALT_TYPE_EMBEDDED;
9125 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9126 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9127 kern_type = KERN_TYPE_SHA256CRYPT;
9128 dgst_size = DGST_SIZE_4_8;
9129 parse_func = sha256crypt_parse_hash;
9130 sort_by_digest = sort_by_digest_4_8;
9131 opti_type = OPTI_TYPE_ZERO_BYTE;
9132 dgst_pos0 = 0;
9133 dgst_pos1 = 1;
9134 dgst_pos2 = 2;
9135 dgst_pos3 = 3;
9136 break;
9137
9138 case 7500: hash_type = HASH_TYPE_KRB5PA;
9139 salt_type = SALT_TYPE_EMBEDDED;
9140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9141 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9142 kern_type = KERN_TYPE_KRB5PA;
9143 dgst_size = DGST_SIZE_4_4;
9144 parse_func = krb5pa_parse_hash;
9145 sort_by_digest = sort_by_digest_4_4;
9146 opti_type = OPTI_TYPE_ZERO_BYTE
9147 | OPTI_TYPE_NOT_ITERATED;
9148 dgst_pos0 = 0;
9149 dgst_pos1 = 1;
9150 dgst_pos2 = 2;
9151 dgst_pos3 = 3;
9152 break;
9153
9154 case 7600: hash_type = HASH_TYPE_SHA1;
9155 salt_type = SALT_TYPE_INTERN;
9156 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9157 opts_type = OPTS_TYPE_PT_GENERATE_BE
9158 | OPTS_TYPE_PT_ADD80
9159 | OPTS_TYPE_PT_ADDBITS15;
9160 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9161 dgst_size = DGST_SIZE_4_5;
9162 parse_func = redmine_parse_hash;
9163 sort_by_digest = sort_by_digest_4_5;
9164 opti_type = OPTI_TYPE_ZERO_BYTE
9165 | OPTI_TYPE_PRECOMPUTE_INIT
9166 | OPTI_TYPE_EARLY_SKIP
9167 | OPTI_TYPE_NOT_ITERATED
9168 | OPTI_TYPE_PREPENDED_SALT;
9169 dgst_pos0 = 3;
9170 dgst_pos1 = 4;
9171 dgst_pos2 = 2;
9172 dgst_pos3 = 1;
9173 break;
9174
9175 case 7700: hash_type = HASH_TYPE_SAPB;
9176 salt_type = SALT_TYPE_EMBEDDED;
9177 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9178 opts_type = OPTS_TYPE_PT_GENERATE_LE
9179 | OPTS_TYPE_PT_UPPER
9180 | OPTS_TYPE_ST_UPPER;
9181 kern_type = KERN_TYPE_SAPB;
9182 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9183 parse_func = sapb_parse_hash;
9184 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9185 opti_type = OPTI_TYPE_ZERO_BYTE
9186 | OPTI_TYPE_PRECOMPUTE_INIT
9187 | OPTI_TYPE_NOT_ITERATED;
9188 dgst_pos0 = 0;
9189 dgst_pos1 = 1;
9190 dgst_pos2 = 2;
9191 dgst_pos3 = 3;
9192 break;
9193
9194 case 7800: hash_type = HASH_TYPE_SAPG;
9195 salt_type = SALT_TYPE_EMBEDDED;
9196 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9197 opts_type = OPTS_TYPE_PT_GENERATE_BE
9198 | OPTS_TYPE_ST_ADD80
9199 | OPTS_TYPE_ST_UPPER;
9200 kern_type = KERN_TYPE_SAPG;
9201 dgst_size = DGST_SIZE_4_5;
9202 parse_func = sapg_parse_hash;
9203 sort_by_digest = sort_by_digest_4_5;
9204 opti_type = OPTI_TYPE_ZERO_BYTE
9205 | OPTI_TYPE_PRECOMPUTE_INIT
9206 | OPTI_TYPE_NOT_ITERATED;
9207 dgst_pos0 = 3;
9208 dgst_pos1 = 4;
9209 dgst_pos2 = 2;
9210 dgst_pos3 = 1;
9211 break;
9212
9213 case 7900: hash_type = HASH_TYPE_SHA512;
9214 salt_type = SALT_TYPE_EMBEDDED;
9215 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9216 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9217 kern_type = KERN_TYPE_DRUPAL7;
9218 dgst_size = DGST_SIZE_8_8;
9219 parse_func = drupal7_parse_hash;
9220 sort_by_digest = sort_by_digest_8_8;
9221 opti_type = OPTI_TYPE_ZERO_BYTE
9222 | OPTI_TYPE_USES_BITS_64;
9223 dgst_pos0 = 0;
9224 dgst_pos1 = 1;
9225 dgst_pos2 = 2;
9226 dgst_pos3 = 3;
9227 break;
9228
9229 case 8000: hash_type = HASH_TYPE_SHA256;
9230 salt_type = SALT_TYPE_EMBEDDED;
9231 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9232 opts_type = OPTS_TYPE_PT_GENERATE_BE
9233 | OPTS_TYPE_PT_UNICODE
9234 | OPTS_TYPE_ST_ADD80
9235 | OPTS_TYPE_ST_HEX;
9236 kern_type = KERN_TYPE_SYBASEASE;
9237 dgst_size = DGST_SIZE_4_8;
9238 parse_func = sybasease_parse_hash;
9239 sort_by_digest = sort_by_digest_4_8;
9240 opti_type = OPTI_TYPE_ZERO_BYTE
9241 | OPTI_TYPE_PRECOMPUTE_INIT
9242 | OPTI_TYPE_EARLY_SKIP
9243 | OPTI_TYPE_NOT_ITERATED
9244 | OPTI_TYPE_RAW_HASH;
9245 dgst_pos0 = 3;
9246 dgst_pos1 = 7;
9247 dgst_pos2 = 2;
9248 dgst_pos3 = 6;
9249 break;
9250
9251 case 8100: hash_type = HASH_TYPE_SHA1;
9252 salt_type = SALT_TYPE_EMBEDDED;
9253 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9254 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9255 kern_type = KERN_TYPE_NETSCALER;
9256 dgst_size = DGST_SIZE_4_5;
9257 parse_func = netscaler_parse_hash;
9258 sort_by_digest = sort_by_digest_4_5;
9259 opti_type = OPTI_TYPE_ZERO_BYTE
9260 | OPTI_TYPE_PRECOMPUTE_INIT
9261 | OPTI_TYPE_PRECOMPUTE_MERKLE
9262 | OPTI_TYPE_EARLY_SKIP
9263 | OPTI_TYPE_NOT_ITERATED
9264 | OPTI_TYPE_PREPENDED_SALT
9265 | OPTI_TYPE_RAW_HASH;
9266 dgst_pos0 = 3;
9267 dgst_pos1 = 4;
9268 dgst_pos2 = 2;
9269 dgst_pos3 = 1;
9270 break;
9271
9272 case 8200: 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_CLOUDKEY;
9277 dgst_size = DGST_SIZE_4_8;
9278 parse_func = cloudkey_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 8300: hash_type = HASH_TYPE_SHA1;
9288 salt_type = SALT_TYPE_EMBEDDED;
9289 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9290 opts_type = OPTS_TYPE_PT_GENERATE_LE
9291 | OPTS_TYPE_ST_HEX
9292 | OPTS_TYPE_ST_ADD80;
9293 kern_type = KERN_TYPE_NSEC3;
9294 dgst_size = DGST_SIZE_4_5;
9295 parse_func = nsec3_parse_hash;
9296 sort_by_digest = sort_by_digest_4_5;
9297 opti_type = OPTI_TYPE_ZERO_BYTE;
9298 dgst_pos0 = 3;
9299 dgst_pos1 = 4;
9300 dgst_pos2 = 2;
9301 dgst_pos3 = 1;
9302 break;
9303
9304 case 8400: hash_type = HASH_TYPE_SHA1;
9305 salt_type = SALT_TYPE_INTERN;
9306 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9307 opts_type = OPTS_TYPE_PT_GENERATE_BE
9308 | OPTS_TYPE_PT_ADD80
9309 | OPTS_TYPE_PT_ADDBITS15;
9310 kern_type = KERN_TYPE_WBB3;
9311 dgst_size = DGST_SIZE_4_5;
9312 parse_func = wbb3_parse_hash;
9313 sort_by_digest = sort_by_digest_4_5;
9314 opti_type = OPTI_TYPE_ZERO_BYTE
9315 | OPTI_TYPE_PRECOMPUTE_INIT
9316 | OPTI_TYPE_NOT_ITERATED;
9317 dgst_pos0 = 3;
9318 dgst_pos1 = 4;
9319 dgst_pos2 = 2;
9320 dgst_pos3 = 1;
9321 break;
9322
9323 case 8500: hash_type = HASH_TYPE_DESRACF;
9324 salt_type = SALT_TYPE_EMBEDDED;
9325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9326 opts_type = OPTS_TYPE_PT_GENERATE_LE
9327 | OPTS_TYPE_ST_UPPER;
9328 kern_type = KERN_TYPE_RACF;
9329 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9330 parse_func = racf_parse_hash;
9331 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9332 opti_type = OPTI_TYPE_ZERO_BYTE
9333 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9334 dgst_pos0 = 0;
9335 dgst_pos1 = 1;
9336 dgst_pos2 = 2;
9337 dgst_pos3 = 3;
9338 break;
9339
9340 case 8600: hash_type = HASH_TYPE_LOTUS5;
9341 salt_type = SALT_TYPE_NONE;
9342 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9343 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9344 kern_type = KERN_TYPE_LOTUS5;
9345 dgst_size = DGST_SIZE_4_4;
9346 parse_func = lotus5_parse_hash;
9347 sort_by_digest = sort_by_digest_4_4;
9348 opti_type = OPTI_TYPE_EARLY_SKIP
9349 | OPTI_TYPE_NOT_ITERATED
9350 | OPTI_TYPE_NOT_SALTED
9351 | OPTI_TYPE_RAW_HASH;
9352 dgst_pos0 = 0;
9353 dgst_pos1 = 1;
9354 dgst_pos2 = 2;
9355 dgst_pos3 = 3;
9356 break;
9357
9358 case 8700: hash_type = HASH_TYPE_LOTUS6;
9359 salt_type = SALT_TYPE_EMBEDDED;
9360 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9361 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9362 kern_type = KERN_TYPE_LOTUS6;
9363 dgst_size = DGST_SIZE_4_4;
9364 parse_func = lotus6_parse_hash;
9365 sort_by_digest = sort_by_digest_4_4;
9366 opti_type = OPTI_TYPE_EARLY_SKIP
9367 | OPTI_TYPE_NOT_ITERATED
9368 | OPTI_TYPE_RAW_HASH;
9369 dgst_pos0 = 0;
9370 dgst_pos1 = 1;
9371 dgst_pos2 = 2;
9372 dgst_pos3 = 3;
9373 break;
9374
9375 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9376 salt_type = SALT_TYPE_EMBEDDED;
9377 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9378 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9379 kern_type = KERN_TYPE_ANDROIDFDE;
9380 dgst_size = DGST_SIZE_4_4;
9381 parse_func = androidfde_parse_hash;
9382 sort_by_digest = sort_by_digest_4_4;
9383 opti_type = OPTI_TYPE_ZERO_BYTE;
9384 dgst_pos0 = 0;
9385 dgst_pos1 = 1;
9386 dgst_pos2 = 2;
9387 dgst_pos3 = 3;
9388 break;
9389
9390 case 8900: hash_type = HASH_TYPE_SCRYPT;
9391 salt_type = SALT_TYPE_EMBEDDED;
9392 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9393 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9394 kern_type = KERN_TYPE_SCRYPT;
9395 dgst_size = DGST_SIZE_4_8;
9396 parse_func = scrypt_parse_hash;
9397 sort_by_digest = sort_by_digest_4_8;
9398 opti_type = OPTI_TYPE_ZERO_BYTE;
9399 dgst_pos0 = 0;
9400 dgst_pos1 = 1;
9401 dgst_pos2 = 2;
9402 dgst_pos3 = 3;
9403 break;
9404
9405 case 9000: hash_type = HASH_TYPE_SHA1;
9406 salt_type = SALT_TYPE_EMBEDDED;
9407 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9408 opts_type = OPTS_TYPE_PT_GENERATE_LE
9409 | OPTS_TYPE_ST_GENERATE_LE;
9410 kern_type = KERN_TYPE_PSAFE2;
9411 dgst_size = DGST_SIZE_4_5;
9412 parse_func = psafe2_parse_hash;
9413 sort_by_digest = sort_by_digest_4_5;
9414 opti_type = OPTI_TYPE_ZERO_BYTE;
9415 dgst_pos0 = 0;
9416 dgst_pos1 = 1;
9417 dgst_pos2 = 2;
9418 dgst_pos3 = 3;
9419 break;
9420
9421 case 9100: hash_type = HASH_TYPE_LOTUS8;
9422 salt_type = SALT_TYPE_EMBEDDED;
9423 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9424 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9425 kern_type = KERN_TYPE_LOTUS8;
9426 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9427 parse_func = lotus8_parse_hash;
9428 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
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 9200: hash_type = HASH_TYPE_SHA256;
9437 salt_type = SALT_TYPE_EMBEDDED;
9438 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9439 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9440 kern_type = KERN_TYPE_PBKDF2_SHA256;
9441 dgst_size = DGST_SIZE_4_32;
9442 parse_func = cisco8_parse_hash;
9443 sort_by_digest = sort_by_digest_4_32;
9444 opti_type = OPTI_TYPE_ZERO_BYTE;
9445 dgst_pos0 = 0;
9446 dgst_pos1 = 1;
9447 dgst_pos2 = 2;
9448 dgst_pos3 = 3;
9449 break;
9450
9451 case 9300: hash_type = HASH_TYPE_SCRYPT;
9452 salt_type = SALT_TYPE_EMBEDDED;
9453 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9454 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9455 kern_type = KERN_TYPE_SCRYPT;
9456 dgst_size = DGST_SIZE_4_8;
9457 parse_func = cisco9_parse_hash;
9458 sort_by_digest = sort_by_digest_4_8;
9459 opti_type = OPTI_TYPE_ZERO_BYTE;
9460 dgst_pos0 = 0;
9461 dgst_pos1 = 1;
9462 dgst_pos2 = 2;
9463 dgst_pos3 = 3;
9464 break;
9465
9466 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9467 salt_type = SALT_TYPE_EMBEDDED;
9468 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9469 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9470 kern_type = KERN_TYPE_OFFICE2007;
9471 dgst_size = DGST_SIZE_4_4;
9472 parse_func = office2007_parse_hash;
9473 sort_by_digest = sort_by_digest_4_4;
9474 opti_type = OPTI_TYPE_ZERO_BYTE;
9475 dgst_pos0 = 0;
9476 dgst_pos1 = 1;
9477 dgst_pos2 = 2;
9478 dgst_pos3 = 3;
9479 break;
9480
9481 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9482 salt_type = SALT_TYPE_EMBEDDED;
9483 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9484 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9485 kern_type = KERN_TYPE_OFFICE2010;
9486 dgst_size = DGST_SIZE_4_4;
9487 parse_func = office2010_parse_hash;
9488 sort_by_digest = sort_by_digest_4_4;
9489 opti_type = OPTI_TYPE_ZERO_BYTE;
9490 dgst_pos0 = 0;
9491 dgst_pos1 = 1;
9492 dgst_pos2 = 2;
9493 dgst_pos3 = 3;
9494 break;
9495
9496 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9497 salt_type = SALT_TYPE_EMBEDDED;
9498 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9499 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9500 kern_type = KERN_TYPE_OFFICE2013;
9501 dgst_size = DGST_SIZE_4_4;
9502 parse_func = office2013_parse_hash;
9503 sort_by_digest = sort_by_digest_4_4;
9504 opti_type = OPTI_TYPE_ZERO_BYTE;
9505 dgst_pos0 = 0;
9506 dgst_pos1 = 1;
9507 dgst_pos2 = 2;
9508 dgst_pos3 = 3;
9509 break;
9510
9511 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9512 salt_type = SALT_TYPE_EMBEDDED;
9513 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9514 opts_type = OPTS_TYPE_PT_GENERATE_LE
9515 | OPTS_TYPE_PT_ADD80
9516 | OPTS_TYPE_PT_UNICODE;
9517 kern_type = KERN_TYPE_OLDOFFICE01;
9518 dgst_size = DGST_SIZE_4_4;
9519 parse_func = oldoffice01_parse_hash;
9520 sort_by_digest = sort_by_digest_4_4;
9521 opti_type = OPTI_TYPE_ZERO_BYTE
9522 | OPTI_TYPE_PRECOMPUTE_INIT
9523 | OPTI_TYPE_NOT_ITERATED;
9524 dgst_pos0 = 0;
9525 dgst_pos1 = 1;
9526 dgst_pos2 = 2;
9527 dgst_pos3 = 3;
9528 break;
9529
9530 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9531 salt_type = SALT_TYPE_EMBEDDED;
9532 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9533 opts_type = OPTS_TYPE_PT_GENERATE_LE
9534 | OPTS_TYPE_PT_ADD80;
9535 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9536 dgst_size = DGST_SIZE_4_4;
9537 parse_func = oldoffice01cm1_parse_hash;
9538 sort_by_digest = sort_by_digest_4_4;
9539 opti_type = OPTI_TYPE_ZERO_BYTE
9540 | OPTI_TYPE_PRECOMPUTE_INIT
9541 | OPTI_TYPE_NOT_ITERATED;
9542 dgst_pos0 = 0;
9543 dgst_pos1 = 1;
9544 dgst_pos2 = 2;
9545 dgst_pos3 = 3;
9546 break;
9547
9548 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9549 salt_type = SALT_TYPE_EMBEDDED;
9550 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9551 opts_type = OPTS_TYPE_PT_GENERATE_LE
9552 | OPTS_TYPE_PT_ADD80
9553 | OPTS_TYPE_PT_UNICODE
9554 | OPTS_TYPE_PT_NEVERCRACK;
9555 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9556 dgst_size = DGST_SIZE_4_4;
9557 parse_func = oldoffice01cm2_parse_hash;
9558 sort_by_digest = sort_by_digest_4_4;
9559 opti_type = OPTI_TYPE_ZERO_BYTE
9560 | OPTI_TYPE_PRECOMPUTE_INIT
9561 | OPTI_TYPE_NOT_ITERATED;
9562 dgst_pos0 = 0;
9563 dgst_pos1 = 1;
9564 dgst_pos2 = 2;
9565 dgst_pos3 = 3;
9566 break;
9567
9568 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9569 salt_type = SALT_TYPE_EMBEDDED;
9570 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9571 opts_type = OPTS_TYPE_PT_GENERATE_BE
9572 | OPTS_TYPE_PT_ADD80
9573 | OPTS_TYPE_PT_UNICODE;
9574 kern_type = KERN_TYPE_OLDOFFICE34;
9575 dgst_size = DGST_SIZE_4_4;
9576 parse_func = oldoffice34_parse_hash;
9577 sort_by_digest = sort_by_digest_4_4;
9578 opti_type = OPTI_TYPE_ZERO_BYTE
9579 | OPTI_TYPE_PRECOMPUTE_INIT
9580 | OPTI_TYPE_NOT_ITERATED;
9581 dgst_pos0 = 0;
9582 dgst_pos1 = 1;
9583 dgst_pos2 = 2;
9584 dgst_pos3 = 3;
9585 break;
9586
9587 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9588 salt_type = SALT_TYPE_EMBEDDED;
9589 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9590 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9591 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9592 dgst_size = DGST_SIZE_4_4;
9593 parse_func = oldoffice34cm1_parse_hash;
9594 sort_by_digest = sort_by_digest_4_4;
9595 opti_type = OPTI_TYPE_ZERO_BYTE
9596 | OPTI_TYPE_PRECOMPUTE_INIT
9597 | OPTI_TYPE_NOT_ITERATED;
9598 dgst_pos0 = 0;
9599 dgst_pos1 = 1;
9600 dgst_pos2 = 2;
9601 dgst_pos3 = 3;
9602 break;
9603
9604 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9605 salt_type = SALT_TYPE_EMBEDDED;
9606 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9607 opts_type = OPTS_TYPE_PT_GENERATE_BE
9608 | OPTS_TYPE_PT_ADD80
9609 | OPTS_TYPE_PT_UNICODE
9610 | OPTS_TYPE_PT_NEVERCRACK;
9611 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9612 dgst_size = DGST_SIZE_4_4;
9613 parse_func = oldoffice34cm2_parse_hash;
9614 sort_by_digest = sort_by_digest_4_4;
9615 opti_type = OPTI_TYPE_ZERO_BYTE
9616 | OPTI_TYPE_PRECOMPUTE_INIT
9617 | OPTI_TYPE_NOT_ITERATED;
9618 dgst_pos0 = 0;
9619 dgst_pos1 = 1;
9620 dgst_pos2 = 2;
9621 dgst_pos3 = 3;
9622 break;
9623
9624 case 9900: hash_type = HASH_TYPE_MD5;
9625 salt_type = SALT_TYPE_NONE;
9626 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9627 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9628 kern_type = KERN_TYPE_RADMIN2;
9629 dgst_size = DGST_SIZE_4_4;
9630 parse_func = radmin2_parse_hash;
9631 sort_by_digest = sort_by_digest_4_4;
9632 opti_type = OPTI_TYPE_ZERO_BYTE
9633 | OPTI_TYPE_PRECOMPUTE_INIT
9634 | OPTI_TYPE_EARLY_SKIP
9635 | OPTI_TYPE_NOT_ITERATED
9636 | OPTI_TYPE_NOT_SALTED;
9637 dgst_pos0 = 0;
9638 dgst_pos1 = 3;
9639 dgst_pos2 = 2;
9640 dgst_pos3 = 1;
9641 break;
9642
9643 case 10000: hash_type = HASH_TYPE_SHA256;
9644 salt_type = SALT_TYPE_EMBEDDED;
9645 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9646 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9647 kern_type = KERN_TYPE_PBKDF2_SHA256;
9648 dgst_size = DGST_SIZE_4_32;
9649 parse_func = djangopbkdf2_parse_hash;
9650 sort_by_digest = sort_by_digest_4_32;
9651 opti_type = OPTI_TYPE_ZERO_BYTE;
9652 dgst_pos0 = 0;
9653 dgst_pos1 = 1;
9654 dgst_pos2 = 2;
9655 dgst_pos3 = 3;
9656 break;
9657
9658 case 10100: hash_type = HASH_TYPE_SIPHASH;
9659 salt_type = SALT_TYPE_EMBEDDED;
9660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9661 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9662 kern_type = KERN_TYPE_SIPHASH;
9663 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9664 parse_func = siphash_parse_hash;
9665 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9666 opti_type = OPTI_TYPE_ZERO_BYTE
9667 | OPTI_TYPE_NOT_ITERATED
9668 | OPTI_TYPE_RAW_HASH;
9669 dgst_pos0 = 0;
9670 dgst_pos1 = 1;
9671 dgst_pos2 = 2;
9672 dgst_pos3 = 3;
9673 break;
9674
9675 case 10200: hash_type = HASH_TYPE_MD5;
9676 salt_type = SALT_TYPE_EMBEDDED;
9677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9678 opts_type = OPTS_TYPE_PT_GENERATE_LE
9679 | OPTS_TYPE_ST_ADD80
9680 | OPTS_TYPE_ST_ADDBITS14;
9681 kern_type = KERN_TYPE_HMACMD5_PW;
9682 dgst_size = DGST_SIZE_4_4;
9683 parse_func = crammd5_parse_hash;
9684 sort_by_digest = sort_by_digest_4_4;
9685 opti_type = OPTI_TYPE_ZERO_BYTE
9686 | OPTI_TYPE_NOT_ITERATED;
9687 dgst_pos0 = 0;
9688 dgst_pos1 = 3;
9689 dgst_pos2 = 2;
9690 dgst_pos3 = 1;
9691 break;
9692
9693 case 10300: hash_type = HASH_TYPE_SHA1;
9694 salt_type = SALT_TYPE_EMBEDDED;
9695 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9696 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9697 kern_type = KERN_TYPE_SAPH_SHA1;
9698 dgst_size = DGST_SIZE_4_5;
9699 parse_func = saph_sha1_parse_hash;
9700 sort_by_digest = sort_by_digest_4_5;
9701 opti_type = OPTI_TYPE_ZERO_BYTE;
9702 dgst_pos0 = 0;
9703 dgst_pos1 = 1;
9704 dgst_pos2 = 2;
9705 dgst_pos3 = 3;
9706 break;
9707
9708 case 10400: hash_type = HASH_TYPE_PDFU16;
9709 salt_type = SALT_TYPE_EMBEDDED;
9710 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9711 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9712 kern_type = KERN_TYPE_PDF11;
9713 dgst_size = DGST_SIZE_4_4;
9714 parse_func = pdf11_parse_hash;
9715 sort_by_digest = sort_by_digest_4_4;
9716 opti_type = OPTI_TYPE_ZERO_BYTE
9717 | OPTI_TYPE_NOT_ITERATED;
9718 dgst_pos0 = 0;
9719 dgst_pos1 = 1;
9720 dgst_pos2 = 2;
9721 dgst_pos3 = 3;
9722 break;
9723
9724 case 10410: hash_type = HASH_TYPE_PDFU16;
9725 salt_type = SALT_TYPE_EMBEDDED;
9726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9727 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9728 kern_type = KERN_TYPE_PDF11CM1;
9729 dgst_size = DGST_SIZE_4_4;
9730 parse_func = pdf11cm1_parse_hash;
9731 sort_by_digest = sort_by_digest_4_4;
9732 opti_type = OPTI_TYPE_ZERO_BYTE
9733 | OPTI_TYPE_NOT_ITERATED;
9734 dgst_pos0 = 0;
9735 dgst_pos1 = 1;
9736 dgst_pos2 = 2;
9737 dgst_pos3 = 3;
9738 break;
9739
9740 case 10420: hash_type = HASH_TYPE_PDFU16;
9741 salt_type = SALT_TYPE_EMBEDDED;
9742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9743 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9744 kern_type = KERN_TYPE_PDF11CM2;
9745 dgst_size = DGST_SIZE_4_4;
9746 parse_func = pdf11cm2_parse_hash;
9747 sort_by_digest = sort_by_digest_4_4;
9748 opti_type = OPTI_TYPE_ZERO_BYTE
9749 | OPTI_TYPE_NOT_ITERATED;
9750 dgst_pos0 = 0;
9751 dgst_pos1 = 1;
9752 dgst_pos2 = 2;
9753 dgst_pos3 = 3;
9754 break;
9755
9756 case 10500: hash_type = HASH_TYPE_PDFU16;
9757 salt_type = SALT_TYPE_EMBEDDED;
9758 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9759 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9760 kern_type = KERN_TYPE_PDF14;
9761 dgst_size = DGST_SIZE_4_4;
9762 parse_func = pdf14_parse_hash;
9763 sort_by_digest = sort_by_digest_4_4;
9764 opti_type = OPTI_TYPE_ZERO_BYTE
9765 | OPTI_TYPE_NOT_ITERATED;
9766 dgst_pos0 = 0;
9767 dgst_pos1 = 1;
9768 dgst_pos2 = 2;
9769 dgst_pos3 = 3;
9770 break;
9771
9772 case 10600: hash_type = HASH_TYPE_SHA256;
9773 salt_type = SALT_TYPE_EMBEDDED;
9774 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9775 opts_type = OPTS_TYPE_PT_GENERATE_BE
9776 | OPTS_TYPE_ST_ADD80
9777 | OPTS_TYPE_ST_ADDBITS15
9778 | OPTS_TYPE_HASH_COPY;
9779 kern_type = KERN_TYPE_SHA256_PWSLT;
9780 dgst_size = DGST_SIZE_4_8;
9781 parse_func = pdf17l3_parse_hash;
9782 sort_by_digest = sort_by_digest_4_8;
9783 opti_type = OPTI_TYPE_ZERO_BYTE
9784 | OPTI_TYPE_PRECOMPUTE_INIT
9785 | OPTI_TYPE_PRECOMPUTE_MERKLE
9786 | OPTI_TYPE_EARLY_SKIP
9787 | OPTI_TYPE_NOT_ITERATED
9788 | OPTI_TYPE_APPENDED_SALT
9789 | OPTI_TYPE_RAW_HASH;
9790 dgst_pos0 = 3;
9791 dgst_pos1 = 7;
9792 dgst_pos2 = 2;
9793 dgst_pos3 = 6;
9794 break;
9795
9796 case 10700: hash_type = HASH_TYPE_PDFU32;
9797 salt_type = SALT_TYPE_EMBEDDED;
9798 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9799 opts_type = OPTS_TYPE_PT_GENERATE_LE
9800 | OPTS_TYPE_HASH_COPY;
9801 kern_type = KERN_TYPE_PDF17L8;
9802 dgst_size = DGST_SIZE_4_8;
9803 parse_func = pdf17l8_parse_hash;
9804 sort_by_digest = sort_by_digest_4_8;
9805 opti_type = OPTI_TYPE_ZERO_BYTE
9806 | OPTI_TYPE_NOT_ITERATED;
9807 dgst_pos0 = 0;
9808 dgst_pos1 = 1;
9809 dgst_pos2 = 2;
9810 dgst_pos3 = 3;
9811 break;
9812
9813 case 10800: hash_type = HASH_TYPE_SHA384;
9814 salt_type = SALT_TYPE_NONE;
9815 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9816 opts_type = OPTS_TYPE_PT_GENERATE_BE
9817 | OPTS_TYPE_PT_ADD80
9818 | OPTS_TYPE_PT_ADDBITS15;
9819 kern_type = KERN_TYPE_SHA384;
9820 dgst_size = DGST_SIZE_8_8;
9821 parse_func = sha384_parse_hash;
9822 sort_by_digest = sort_by_digest_8_8;
9823 opti_type = OPTI_TYPE_ZERO_BYTE
9824 | OPTI_TYPE_PRECOMPUTE_INIT
9825 | OPTI_TYPE_PRECOMPUTE_MERKLE
9826 | OPTI_TYPE_EARLY_SKIP
9827 | OPTI_TYPE_NOT_ITERATED
9828 | OPTI_TYPE_NOT_SALTED
9829 | OPTI_TYPE_USES_BITS_64
9830 | OPTI_TYPE_RAW_HASH;
9831 dgst_pos0 = 6;
9832 dgst_pos1 = 7;
9833 dgst_pos2 = 4;
9834 dgst_pos3 = 5;
9835 break;
9836
9837 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9838 salt_type = SALT_TYPE_EMBEDDED;
9839 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9840 opts_type = OPTS_TYPE_PT_GENERATE_LE
9841 | OPTS_TYPE_ST_BASE64
9842 | OPTS_TYPE_HASH_COPY;
9843 kern_type = KERN_TYPE_PBKDF2_SHA256;
9844 dgst_size = DGST_SIZE_4_32;
9845 parse_func = pbkdf2_sha256_parse_hash;
9846 sort_by_digest = sort_by_digest_4_32;
9847 opti_type = OPTI_TYPE_ZERO_BYTE;
9848 dgst_pos0 = 0;
9849 dgst_pos1 = 1;
9850 dgst_pos2 = 2;
9851 dgst_pos3 = 3;
9852 break;
9853
9854 case 11000: hash_type = HASH_TYPE_MD5;
9855 salt_type = SALT_TYPE_INTERN;
9856 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9857 opts_type = OPTS_TYPE_PT_GENERATE_LE
9858 | OPTS_TYPE_PT_ADD80;
9859 kern_type = KERN_TYPE_PRESTASHOP;
9860 dgst_size = DGST_SIZE_4_4;
9861 parse_func = prestashop_parse_hash;
9862 sort_by_digest = sort_by_digest_4_4;
9863 opti_type = OPTI_TYPE_ZERO_BYTE
9864 | OPTI_TYPE_PRECOMPUTE_INIT
9865 | OPTI_TYPE_NOT_ITERATED
9866 | OPTI_TYPE_PREPENDED_SALT;
9867 dgst_pos0 = 0;
9868 dgst_pos1 = 3;
9869 dgst_pos2 = 2;
9870 dgst_pos3 = 1;
9871 break;
9872
9873 case 11100: hash_type = HASH_TYPE_MD5;
9874 salt_type = SALT_TYPE_EMBEDDED;
9875 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9876 opts_type = OPTS_TYPE_PT_GENERATE_LE
9877 | OPTS_TYPE_ST_ADD80;
9878 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9879 dgst_size = DGST_SIZE_4_4;
9880 parse_func = postgresql_auth_parse_hash;
9881 sort_by_digest = sort_by_digest_4_4;
9882 opti_type = OPTI_TYPE_ZERO_BYTE
9883 | OPTI_TYPE_PRECOMPUTE_INIT
9884 | OPTI_TYPE_PRECOMPUTE_MERKLE
9885 | OPTI_TYPE_EARLY_SKIP;
9886 dgst_pos0 = 0;
9887 dgst_pos1 = 3;
9888 dgst_pos2 = 2;
9889 dgst_pos3 = 1;
9890 break;
9891
9892 case 11200: hash_type = HASH_TYPE_SHA1;
9893 salt_type = SALT_TYPE_EMBEDDED;
9894 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9895 opts_type = OPTS_TYPE_PT_GENERATE_BE
9896 | OPTS_TYPE_PT_ADD80
9897 | OPTS_TYPE_ST_HEX;
9898 kern_type = KERN_TYPE_MYSQL_AUTH;
9899 dgst_size = DGST_SIZE_4_5;
9900 parse_func = mysql_auth_parse_hash;
9901 sort_by_digest = sort_by_digest_4_5;
9902 opti_type = OPTI_TYPE_ZERO_BYTE
9903 | OPTI_TYPE_EARLY_SKIP;
9904 dgst_pos0 = 3;
9905 dgst_pos1 = 4;
9906 dgst_pos2 = 2;
9907 dgst_pos3 = 1;
9908 break;
9909
9910 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9911 salt_type = SALT_TYPE_EMBEDDED;
9912 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9913 opts_type = OPTS_TYPE_PT_GENERATE_LE
9914 | OPTS_TYPE_ST_HEX
9915 | OPTS_TYPE_ST_ADD80;
9916 kern_type = KERN_TYPE_BITCOIN_WALLET;
9917 dgst_size = DGST_SIZE_4_4;
9918 parse_func = bitcoin_wallet_parse_hash;
9919 sort_by_digest = sort_by_digest_4_4;
9920 opti_type = OPTI_TYPE_ZERO_BYTE;
9921 dgst_pos0 = 0;
9922 dgst_pos1 = 1;
9923 dgst_pos2 = 2;
9924 dgst_pos3 = 3;
9925 break;
9926
9927 case 11400: hash_type = HASH_TYPE_MD5;
9928 salt_type = SALT_TYPE_EMBEDDED;
9929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9930 opts_type = OPTS_TYPE_PT_GENERATE_LE
9931 | OPTS_TYPE_PT_ADD80
9932 | OPTS_TYPE_HASH_COPY;
9933 kern_type = KERN_TYPE_SIP_AUTH;
9934 dgst_size = DGST_SIZE_4_4;
9935 parse_func = sip_auth_parse_hash;
9936 sort_by_digest = sort_by_digest_4_4;
9937 opti_type = OPTI_TYPE_ZERO_BYTE;
9938 dgst_pos0 = 0;
9939 dgst_pos1 = 3;
9940 dgst_pos2 = 2;
9941 dgst_pos3 = 1;
9942 break;
9943
9944 case 11500: hash_type = HASH_TYPE_CRC32;
9945 salt_type = SALT_TYPE_INTERN;
9946 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9947 opts_type = OPTS_TYPE_PT_GENERATE_LE
9948 | OPTS_TYPE_ST_GENERATE_LE
9949 | OPTS_TYPE_ST_HEX;
9950 kern_type = KERN_TYPE_CRC32;
9951 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9952 parse_func = crc32_parse_hash;
9953 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9954 opti_type = OPTI_TYPE_ZERO_BYTE;
9955 dgst_pos0 = 0;
9956 dgst_pos1 = 1;
9957 dgst_pos2 = 2;
9958 dgst_pos3 = 3;
9959 break;
9960
9961 case 11600: hash_type = HASH_TYPE_AES;
9962 salt_type = SALT_TYPE_EMBEDDED;
9963 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9964 opts_type = OPTS_TYPE_PT_GENERATE_LE
9965 | OPTS_TYPE_PT_NEVERCRACK;
9966 kern_type = KERN_TYPE_SEVEN_ZIP;
9967 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9968 parse_func = seven_zip_parse_hash;
9969 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9970 opti_type = OPTI_TYPE_ZERO_BYTE;
9971 dgst_pos0 = 0;
9972 dgst_pos1 = 1;
9973 dgst_pos2 = 2;
9974 dgst_pos3 = 3;
9975 break;
9976
9977 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9978 salt_type = SALT_TYPE_NONE;
9979 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9980 opts_type = OPTS_TYPE_PT_GENERATE_LE
9981 | OPTS_TYPE_PT_ADD01;
9982 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9983 dgst_size = DGST_SIZE_4_8;
9984 parse_func = gost2012sbog_256_parse_hash;
9985 sort_by_digest = sort_by_digest_4_8;
9986 opti_type = OPTI_TYPE_ZERO_BYTE;
9987 dgst_pos0 = 0;
9988 dgst_pos1 = 1;
9989 dgst_pos2 = 2;
9990 dgst_pos3 = 3;
9991 break;
9992
9993 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9994 salt_type = SALT_TYPE_NONE;
9995 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9996 opts_type = OPTS_TYPE_PT_GENERATE_LE
9997 | OPTS_TYPE_PT_ADD01;
9998 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9999 dgst_size = DGST_SIZE_4_16;
10000 parse_func = gost2012sbog_512_parse_hash;
10001 sort_by_digest = sort_by_digest_4_16;
10002 opti_type = OPTI_TYPE_ZERO_BYTE;
10003 dgst_pos0 = 0;
10004 dgst_pos1 = 1;
10005 dgst_pos2 = 2;
10006 dgst_pos3 = 3;
10007 break;
10008
10009 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10010 salt_type = SALT_TYPE_EMBEDDED;
10011 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10012 opts_type = OPTS_TYPE_PT_GENERATE_LE
10013 | OPTS_TYPE_ST_BASE64
10014 | OPTS_TYPE_HASH_COPY;
10015 kern_type = KERN_TYPE_PBKDF2_MD5;
10016 dgst_size = DGST_SIZE_4_32;
10017 parse_func = pbkdf2_md5_parse_hash;
10018 sort_by_digest = sort_by_digest_4_32;
10019 opti_type = OPTI_TYPE_ZERO_BYTE;
10020 dgst_pos0 = 0;
10021 dgst_pos1 = 1;
10022 dgst_pos2 = 2;
10023 dgst_pos3 = 3;
10024 break;
10025
10026 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10027 salt_type = SALT_TYPE_EMBEDDED;
10028 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10029 opts_type = OPTS_TYPE_PT_GENERATE_LE
10030 | OPTS_TYPE_ST_BASE64
10031 | OPTS_TYPE_HASH_COPY;
10032 kern_type = KERN_TYPE_PBKDF2_SHA1;
10033 dgst_size = DGST_SIZE_4_32;
10034 parse_func = pbkdf2_sha1_parse_hash;
10035 sort_by_digest = sort_by_digest_4_32;
10036 opti_type = OPTI_TYPE_ZERO_BYTE;
10037 dgst_pos0 = 0;
10038 dgst_pos1 = 1;
10039 dgst_pos2 = 2;
10040 dgst_pos3 = 3;
10041 break;
10042
10043 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10044 salt_type = SALT_TYPE_EMBEDDED;
10045 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10046 opts_type = OPTS_TYPE_PT_GENERATE_LE
10047 | OPTS_TYPE_ST_BASE64
10048 | OPTS_TYPE_HASH_COPY;
10049 kern_type = KERN_TYPE_PBKDF2_SHA512;
10050 dgst_size = DGST_SIZE_8_16;
10051 parse_func = pbkdf2_sha512_parse_hash;
10052 sort_by_digest = sort_by_digest_8_16;
10053 opti_type = OPTI_TYPE_ZERO_BYTE
10054 | OPTI_TYPE_USES_BITS_64;
10055 dgst_pos0 = 0;
10056 dgst_pos1 = 1;
10057 dgst_pos2 = 2;
10058 dgst_pos3 = 3;
10059 break;
10060
10061 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10062 salt_type = SALT_TYPE_EMBEDDED;
10063 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10064 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10065 kern_type = KERN_TYPE_ECRYPTFS;
10066 dgst_size = DGST_SIZE_8_8;
10067 parse_func = ecryptfs_parse_hash;
10068 sort_by_digest = sort_by_digest_8_8;
10069 opti_type = OPTI_TYPE_ZERO_BYTE
10070 | OPTI_TYPE_USES_BITS_64;
10071 dgst_pos0 = 0;
10072 dgst_pos1 = 1;
10073 dgst_pos2 = 2;
10074 dgst_pos3 = 3;
10075 break;
10076
10077 case 12300: hash_type = HASH_TYPE_ORACLET;
10078 salt_type = SALT_TYPE_EMBEDDED;
10079 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10080 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10081 kern_type = KERN_TYPE_ORACLET;
10082 dgst_size = DGST_SIZE_8_16;
10083 parse_func = oraclet_parse_hash;
10084 sort_by_digest = sort_by_digest_8_16;
10085 opti_type = OPTI_TYPE_ZERO_BYTE
10086 | OPTI_TYPE_USES_BITS_64;
10087 dgst_pos0 = 0;
10088 dgst_pos1 = 1;
10089 dgst_pos2 = 2;
10090 dgst_pos3 = 3;
10091 break;
10092
10093 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10094 salt_type = SALT_TYPE_EMBEDDED;
10095 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10096 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10097 kern_type = KERN_TYPE_BSDICRYPT;
10098 dgst_size = DGST_SIZE_4_4;
10099 parse_func = bsdicrypt_parse_hash;
10100 sort_by_digest = sort_by_digest_4_4;
10101 opti_type = OPTI_TYPE_ZERO_BYTE
10102 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10103 dgst_pos0 = 0;
10104 dgst_pos1 = 1;
10105 dgst_pos2 = 2;
10106 dgst_pos3 = 3;
10107 break;
10108
10109 case 12500: hash_type = HASH_TYPE_RAR3HP;
10110 salt_type = SALT_TYPE_EMBEDDED;
10111 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10112 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10113 kern_type = KERN_TYPE_RAR3;
10114 dgst_size = DGST_SIZE_4_4;
10115 parse_func = rar3hp_parse_hash;
10116 sort_by_digest = sort_by_digest_4_4;
10117 opti_type = OPTI_TYPE_ZERO_BYTE;
10118 dgst_pos0 = 0;
10119 dgst_pos1 = 1;
10120 dgst_pos2 = 2;
10121 dgst_pos3 = 3;
10122 break;
10123
10124 case 12600: hash_type = HASH_TYPE_SHA256;
10125 salt_type = SALT_TYPE_INTERN;
10126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10127 opts_type = OPTS_TYPE_PT_GENERATE_BE
10128 | OPTS_TYPE_PT_ADD80;
10129 kern_type = KERN_TYPE_CF10;
10130 dgst_size = DGST_SIZE_4_8;
10131 parse_func = cf10_parse_hash;
10132 sort_by_digest = sort_by_digest_4_8;
10133 opti_type = OPTI_TYPE_ZERO_BYTE
10134 | OPTI_TYPE_PRECOMPUTE_INIT
10135 | OPTI_TYPE_EARLY_SKIP
10136 | OPTI_TYPE_NOT_ITERATED;
10137 dgst_pos0 = 3;
10138 dgst_pos1 = 7;
10139 dgst_pos2 = 2;
10140 dgst_pos3 = 6;
10141 break;
10142
10143 case 12700: hash_type = HASH_TYPE_AES;
10144 salt_type = SALT_TYPE_EMBEDDED;
10145 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10146 opts_type = OPTS_TYPE_PT_GENERATE_LE
10147 | OPTS_TYPE_HASH_COPY;
10148 kern_type = KERN_TYPE_MYWALLET;
10149 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10150 parse_func = mywallet_parse_hash;
10151 sort_by_digest = sort_by_digest_4_5;
10152 opti_type = OPTI_TYPE_ZERO_BYTE;
10153 dgst_pos0 = 0;
10154 dgst_pos1 = 1;
10155 dgst_pos2 = 2;
10156 dgst_pos3 = 3;
10157 break;
10158
10159 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10160 salt_type = SALT_TYPE_EMBEDDED;
10161 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10162 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10163 kern_type = KERN_TYPE_MS_DRSR;
10164 dgst_size = DGST_SIZE_4_8;
10165 parse_func = ms_drsr_parse_hash;
10166 sort_by_digest = sort_by_digest_4_8;
10167 opti_type = OPTI_TYPE_ZERO_BYTE;
10168 dgst_pos0 = 0;
10169 dgst_pos1 = 1;
10170 dgst_pos2 = 2;
10171 dgst_pos3 = 3;
10172 break;
10173
10174 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10175 salt_type = SALT_TYPE_EMBEDDED;
10176 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10177 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10178 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10179 dgst_size = DGST_SIZE_4_8;
10180 parse_func = androidfde_samsung_parse_hash;
10181 sort_by_digest = sort_by_digest_4_8;
10182 opti_type = OPTI_TYPE_ZERO_BYTE;
10183 dgst_pos0 = 0;
10184 dgst_pos1 = 1;
10185 dgst_pos2 = 2;
10186 dgst_pos3 = 3;
10187 break;
10188
10189 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10190 salt_type = SALT_TYPE_EMBEDDED;
10191 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10192 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10193 kern_type = KERN_TYPE_RAR5;
10194 dgst_size = DGST_SIZE_4_4;
10195 parse_func = rar5_parse_hash;
10196 sort_by_digest = sort_by_digest_4_4;
10197 opti_type = OPTI_TYPE_ZERO_BYTE;
10198 dgst_pos0 = 0;
10199 dgst_pos1 = 1;
10200 dgst_pos2 = 2;
10201 dgst_pos3 = 3;
10202 break;
10203
10204 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10205 salt_type = SALT_TYPE_EMBEDDED;
10206 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10207 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10208 kern_type = KERN_TYPE_KRB5TGS;
10209 dgst_size = DGST_SIZE_4_4;
10210 parse_func = krb5tgs_parse_hash;
10211 sort_by_digest = sort_by_digest_4_4;
10212 opti_type = OPTI_TYPE_ZERO_BYTE
10213 | OPTI_TYPE_NOT_ITERATED;
10214 dgst_pos0 = 0;
10215 dgst_pos1 = 1;
10216 dgst_pos2 = 2;
10217 dgst_pos3 = 3;
10218 break;
10219
10220 case 13200: hash_type = HASH_TYPE_AES;
10221 salt_type = SALT_TYPE_EMBEDDED;
10222 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10223 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10224 kern_type = KERN_TYPE_AXCRYPT;
10225 dgst_size = DGST_SIZE_4_4;
10226 parse_func = axcrypt_parse_hash;
10227 sort_by_digest = sort_by_digest_4_4;
10228 opti_type = OPTI_TYPE_ZERO_BYTE;
10229 dgst_pos0 = 0;
10230 dgst_pos1 = 1;
10231 dgst_pos2 = 2;
10232 dgst_pos3 = 3;
10233 break;
10234
10235 default: usage_mini_print (PROGNAME); return (-1);
10236 }
10237
10238 /**
10239 * parser
10240 */
10241
10242 data.parse_func = parse_func;
10243
10244 /**
10245 * misc stuff
10246 */
10247
10248 if (hex_salt)
10249 {
10250 if (salt_type == SALT_TYPE_INTERN)
10251 {
10252 opts_type |= OPTS_TYPE_ST_HEX;
10253 }
10254 else
10255 {
10256 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10257
10258 return (-1);
10259 }
10260 }
10261
10262 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10263 | (salt_type == SALT_TYPE_EXTERN)
10264 | (salt_type == SALT_TYPE_EMBEDDED)
10265 | (salt_type == SALT_TYPE_VIRTUAL));
10266
10267 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10268
10269 data.hash_type = hash_type;
10270 data.attack_mode = attack_mode;
10271 data.attack_kern = attack_kern;
10272 data.attack_exec = attack_exec;
10273 data.kern_type = kern_type;
10274 data.opts_type = opts_type;
10275 data.dgst_size = dgst_size;
10276 data.salt_type = salt_type;
10277 data.isSalted = isSalted;
10278 data.sort_by_digest = sort_by_digest;
10279 data.dgst_pos0 = dgst_pos0;
10280 data.dgst_pos1 = dgst_pos1;
10281 data.dgst_pos2 = dgst_pos2;
10282 data.dgst_pos3 = dgst_pos3;
10283
10284 esalt_size = 0;
10285
10286 switch (hash_mode)
10287 {
10288 case 2500: esalt_size = sizeof (wpa_t); break;
10289 case 5300: esalt_size = sizeof (ikepsk_t); break;
10290 case 5400: esalt_size = sizeof (ikepsk_t); break;
10291 case 5500: esalt_size = sizeof (netntlm_t); break;
10292 case 5600: esalt_size = sizeof (netntlm_t); break;
10293 case 6211: esalt_size = sizeof (tc_t); break;
10294 case 6212: esalt_size = sizeof (tc_t); break;
10295 case 6213: esalt_size = sizeof (tc_t); break;
10296 case 6221: esalt_size = sizeof (tc_t); break;
10297 case 6222: esalt_size = sizeof (tc_t); break;
10298 case 6223: esalt_size = sizeof (tc_t); break;
10299 case 6231: esalt_size = sizeof (tc_t); break;
10300 case 6232: esalt_size = sizeof (tc_t); break;
10301 case 6233: esalt_size = sizeof (tc_t); break;
10302 case 6241: esalt_size = sizeof (tc_t); break;
10303 case 6242: esalt_size = sizeof (tc_t); break;
10304 case 6243: esalt_size = sizeof (tc_t); break;
10305 case 6600: esalt_size = sizeof (agilekey_t); break;
10306 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10307 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10308 case 7300: esalt_size = sizeof (rakp_t); break;
10309 case 7500: esalt_size = sizeof (krb5pa_t); break;
10310 case 8200: esalt_size = sizeof (cloudkey_t); break;
10311 case 8800: esalt_size = sizeof (androidfde_t); break;
10312 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10313 case 9400: esalt_size = sizeof (office2007_t); break;
10314 case 9500: esalt_size = sizeof (office2010_t); break;
10315 case 9600: esalt_size = sizeof (office2013_t); break;
10316 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10317 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10318 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10319 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10320 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10321 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10322 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10323 case 10200: esalt_size = sizeof (cram_md5_t); break;
10324 case 10400: esalt_size = sizeof (pdf_t); break;
10325 case 10410: esalt_size = sizeof (pdf_t); break;
10326 case 10420: esalt_size = sizeof (pdf_t); break;
10327 case 10500: esalt_size = sizeof (pdf_t); break;
10328 case 10600: esalt_size = sizeof (pdf_t); break;
10329 case 10700: esalt_size = sizeof (pdf_t); break;
10330 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10331 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10332 case 11400: esalt_size = sizeof (sip_t); break;
10333 case 11600: esalt_size = sizeof (seven_zip_t); break;
10334 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10335 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10336 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10337 case 13000: esalt_size = sizeof (rar5_t); break;
10338 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10339 }
10340
10341 data.esalt_size = esalt_size;
10342
10343 /**
10344 * choose dictionary parser
10345 */
10346
10347 if (hash_type == HASH_TYPE_LM)
10348 {
10349 get_next_word_func = get_next_word_lm;
10350 }
10351 else if (opts_type & OPTS_TYPE_PT_UPPER)
10352 {
10353 get_next_word_func = get_next_word_uc;
10354 }
10355 else
10356 {
10357 get_next_word_func = get_next_word_std;
10358 }
10359
10360 /**
10361 * dictstat
10362 */
10363
10364 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10365
10366 #ifdef _POSIX
10367 size_t dictstat_nmemb = 0;
10368 #endif
10369
10370 #ifdef _WIN
10371 uint dictstat_nmemb = 0;
10372 #endif
10373
10374 char dictstat[256] = { 0 };
10375
10376 FILE *dictstat_fp = NULL;
10377
10378 if (keyspace == 0)
10379 {
10380 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10381
10382 dictstat_fp = fopen (dictstat, "rb");
10383
10384 if (dictstat_fp)
10385 {
10386 #ifdef _POSIX
10387 struct stat tmpstat;
10388
10389 fstat (fileno (dictstat_fp), &tmpstat);
10390 #endif
10391
10392 #ifdef _WIN
10393 struct stat64 tmpstat;
10394
10395 _fstat64 (fileno (dictstat_fp), &tmpstat);
10396 #endif
10397
10398 if (tmpstat.st_mtime < COMPTIME)
10399 {
10400 /* with v0.15 the format changed so we have to ensure user is using a good version
10401 since there is no version-header in the dictstat file */
10402
10403 fclose (dictstat_fp);
10404
10405 unlink (dictstat);
10406 }
10407 else
10408 {
10409 while (!feof (dictstat_fp))
10410 {
10411 dictstat_t d;
10412
10413 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10414
10415 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10416
10417 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10418 {
10419 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10420
10421 return -1;
10422 }
10423 }
10424
10425 fclose (dictstat_fp);
10426 }
10427 }
10428 }
10429
10430 /**
10431 * potfile
10432 */
10433
10434 char potfile[256] = { 0 };
10435
10436 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10437
10438 data.pot_fp = NULL;
10439
10440 FILE *out_fp = NULL;
10441 FILE *pot_fp = NULL;
10442
10443 if (show == 1 || left == 1)
10444 {
10445 pot_fp = fopen (potfile, "rb");
10446
10447 if (pot_fp == NULL)
10448 {
10449 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10450
10451 return (-1);
10452 }
10453
10454 if (outfile != NULL)
10455 {
10456 if ((out_fp = fopen (outfile, "ab")) == NULL)
10457 {
10458 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10459
10460 fclose (pot_fp);
10461
10462 return (-1);
10463 }
10464 }
10465 else
10466 {
10467 out_fp = stdout;
10468 }
10469 }
10470 else
10471 {
10472 if (potfile_disable == 0)
10473 {
10474 pot_fp = fopen (potfile, "ab");
10475
10476 if (pot_fp == NULL)
10477 {
10478 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10479
10480 return (-1);
10481 }
10482
10483 data.pot_fp = pot_fp;
10484 }
10485 }
10486
10487 pot_t *pot = NULL;
10488
10489 uint pot_cnt = 0;
10490 uint pot_avail = 0;
10491
10492 if (show == 1 || left == 1)
10493 {
10494 SUPPRESS_OUTPUT = 1;
10495
10496 pot_avail = count_lines (pot_fp);
10497
10498 rewind (pot_fp);
10499
10500 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10501
10502 uint pot_hashes_avail = 0;
10503
10504 uint line_num = 0;
10505
10506 while (!feof (pot_fp))
10507 {
10508 line_num++;
10509
10510 char line_buf[BUFSIZ] = { 0 };
10511
10512 int line_len = fgetl (pot_fp, line_buf);
10513
10514 if (line_len == 0) continue;
10515
10516 char *plain_buf = line_buf + line_len;
10517
10518 pot_t *pot_ptr = &pot[pot_cnt];
10519
10520 hash_t *hashes_buf = &pot_ptr->hash;
10521
10522 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10523 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10524
10525 if (pot_cnt == pot_hashes_avail)
10526 {
10527 uint pos = 0;
10528
10529 for (pos = 0; pos < INCR_POT; pos++)
10530 {
10531 if ((pot_cnt + pos) >= pot_avail) break;
10532
10533 pot_t *tmp_pot = &pot[pot_cnt + pos];
10534
10535 hash_t *tmp_hash = &tmp_pot->hash;
10536
10537 tmp_hash->digest = mymalloc (dgst_size);
10538
10539 if (isSalted)
10540 {
10541 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10542 }
10543
10544 if (esalt_size)
10545 {
10546 tmp_hash->esalt = mymalloc (esalt_size);
10547 }
10548
10549 pot_hashes_avail++;
10550 }
10551 }
10552
10553 int plain_len = 0;
10554
10555 int parser_status;
10556
10557 int iter = MAX_CUT_TRIES;
10558
10559 do
10560 {
10561 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10562 {
10563 if (line_buf[i] == ':')
10564 {
10565 line_len--;
10566
10567 break;
10568 }
10569 }
10570
10571 if (data.hash_mode != 2500)
10572 {
10573 parser_status = parse_func (line_buf, line_len, hashes_buf);
10574 }
10575 else
10576 {
10577 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10578
10579 if (line_len > max_salt_size)
10580 {
10581 parser_status = PARSER_GLOBAL_LENGTH;
10582 }
10583 else
10584 {
10585 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10586
10587 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10588
10589 hashes_buf->salt->salt_len = line_len;
10590
10591 parser_status = PARSER_OK;
10592 }
10593 }
10594
10595 // if NOT parsed without error, we add the ":" to the plain
10596
10597 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10598 {
10599 plain_len++;
10600 plain_buf--;
10601 }
10602
10603 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10604
10605 if (parser_status < PARSER_GLOBAL_ZERO)
10606 {
10607 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10608
10609 continue;
10610 }
10611
10612 if (plain_len >= 255) continue;
10613
10614 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10615
10616 pot_ptr->plain_len = plain_len;
10617
10618 pot_cnt++;
10619 }
10620
10621 fclose (pot_fp);
10622
10623 SUPPRESS_OUTPUT = 0;
10624
10625 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10626 }
10627
10628 /**
10629 * word len
10630 */
10631
10632 uint pw_min = PW_MIN;
10633 uint pw_max = PW_MAX;
10634
10635 switch (hash_mode)
10636 {
10637 case 400: if (pw_max > 40) pw_max = 40;
10638 break;
10639 case 500: if (pw_max > 16) pw_max = 16;
10640 break;
10641 case 1500: if (pw_max > 8) pw_max = 8;
10642 break;
10643 case 1600: if (pw_max > 16) pw_max = 16;
10644 break;
10645 case 1800: if (pw_max > 16) pw_max = 16;
10646 break;
10647 case 2100: if (pw_max > 16) pw_max = 16;
10648 break;
10649 case 2500: if (pw_min < 8) pw_min = 8;
10650 break;
10651 case 3000: if (pw_max > 7) pw_max = 7;
10652 break;
10653 case 5200: if (pw_max > 24) pw_max = 24;
10654 break;
10655 case 5800: if (pw_max > 16) pw_max = 16;
10656 break;
10657 case 6300: if (pw_max > 16) pw_max = 16;
10658 break;
10659 case 7400: if (pw_max > 16) pw_max = 16;
10660 break;
10661 case 7900: if (pw_max > 48) pw_max = 48;
10662 break;
10663 case 8500: if (pw_max > 8) pw_max = 8;
10664 break;
10665 case 8600: if (pw_max > 16) pw_max = 16;
10666 break;
10667 case 9710: pw_min = 5;
10668 pw_max = 5;
10669 break;
10670 case 9810: pw_min = 5;
10671 pw_max = 5;
10672 break;
10673 case 10410: pw_min = 5;
10674 pw_max = 5;
10675 break;
10676 case 10300: if (pw_max < 3) pw_min = 3;
10677 if (pw_max > 40) pw_max = 40;
10678 break;
10679 case 10500: if (pw_max < 3) pw_min = 3;
10680 if (pw_max > 40) pw_max = 40;
10681 break;
10682 case 10700: if (pw_max > 16) pw_max = 16;
10683 break;
10684 case 11300: if (pw_max > 40) pw_max = 40;
10685 break;
10686 case 12500: if (pw_max > 20) pw_max = 20;
10687 break;
10688 case 12800: if (pw_max > 24) pw_max = 24;
10689 break;
10690 }
10691
10692 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10693 {
10694 switch (attack_kern)
10695 {
10696 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10697 break;
10698 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10699 break;
10700 }
10701 }
10702
10703 /**
10704 * charsets : keep them together for more easy maintainnce
10705 */
10706
10707 cs_t mp_sys[6] = { { { 0 }, 0 } };
10708 cs_t mp_usr[4] = { { { 0 }, 0 } };
10709
10710 mp_setup_sys (mp_sys);
10711
10712 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10713 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10714 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10715 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10716
10717 /**
10718 * load hashes, part I: find input mode, count hashes
10719 */
10720
10721 uint hashlist_mode = 0;
10722 uint hashlist_format = HLFMT_HASHCAT;
10723
10724 uint hashes_avail = 0;
10725
10726 if (benchmark == 0)
10727 {
10728 struct stat f;
10729
10730 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10731
10732 if ((hash_mode == 2500) ||
10733 (hash_mode == 5200) ||
10734 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10735 (hash_mode == 9000))
10736 {
10737 hashlist_mode = HL_MODE_ARG;
10738
10739 char *hashfile = myargv[optind];
10740
10741 data.hashfile = hashfile;
10742
10743 logfile_top_var_string ("target", hashfile);
10744 }
10745
10746 if (hashlist_mode == HL_MODE_ARG)
10747 {
10748 if (hash_mode == 2500)
10749 {
10750 struct stat st;
10751
10752 if (stat (data.hashfile, &st) == -1)
10753 {
10754 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10755
10756 return (-1);
10757 }
10758
10759 hashes_avail = st.st_size / sizeof (hccap_t);
10760 }
10761 else
10762 {
10763 hashes_avail = 1;
10764 }
10765 }
10766 else if (hashlist_mode == HL_MODE_FILE)
10767 {
10768 char *hashfile = myargv[optind];
10769
10770 data.hashfile = hashfile;
10771
10772 logfile_top_var_string ("target", hashfile);
10773
10774 FILE *fp = NULL;
10775
10776 if ((fp = fopen (hashfile, "rb")) == NULL)
10777 {
10778 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10779
10780 return (-1);
10781 }
10782
10783 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10784
10785 hashes_avail = count_lines (fp);
10786
10787 rewind (fp);
10788
10789 if (hashes_avail == 0)
10790 {
10791 log_error ("ERROR: hashfile is empty or corrupt");
10792
10793 fclose (fp);
10794
10795 return (-1);
10796 }
10797
10798 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10799
10800 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10801 {
10802 log_error ("ERROR: remove not supported in native hashfile-format mode");
10803
10804 fclose (fp);
10805
10806 return (-1);
10807 }
10808
10809 fclose (fp);
10810 }
10811 }
10812 else
10813 {
10814 hashlist_mode = HL_MODE_ARG;
10815
10816 hashes_avail = 1;
10817 }
10818
10819 if (hash_mode == 3000) hashes_avail *= 2;
10820
10821 data.hashlist_mode = hashlist_mode;
10822 data.hashlist_format = hashlist_format;
10823
10824 logfile_top_uint (hashlist_mode);
10825 logfile_top_uint (hashlist_format);
10826
10827 /**
10828 * load hashes, part II: allocate required memory, set pointers
10829 */
10830
10831 hash_t *hashes_buf = NULL;
10832 void *digests_buf = NULL;
10833 salt_t *salts_buf = NULL;
10834 void *esalts_buf = NULL;
10835
10836 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10837
10838 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10839
10840 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10841 {
10842 u32 hash_pos;
10843
10844 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10845 {
10846 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10847
10848 hashes_buf[hash_pos].hash_info = hash_info;
10849
10850 if (username && (remove || show || left))
10851 {
10852 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10853 }
10854
10855 if (benchmark)
10856 {
10857 hash_info->orighash = (char *) mymalloc (256);
10858 }
10859 }
10860 }
10861
10862 if (isSalted)
10863 {
10864 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10865
10866 if (esalt_size)
10867 {
10868 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10869 }
10870 }
10871 else
10872 {
10873 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10874 }
10875
10876 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10877 {
10878 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10879
10880 if (isSalted)
10881 {
10882 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10883
10884 if (esalt_size)
10885 {
10886 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10887 }
10888 }
10889 else
10890 {
10891 hashes_buf[hash_pos].salt = &salts_buf[0];
10892 }
10893 }
10894
10895 /**
10896 * load hashes, part III: parse hashes or generate them if benchmark
10897 */
10898
10899 uint hashes_cnt = 0;
10900
10901 if (benchmark == 0)
10902 {
10903 if (keyspace == 1)
10904 {
10905 // useless to read hash file for keyspace, cheat a little bit w/ optind
10906 }
10907 else if (hashes_avail == 0)
10908 {
10909 }
10910 else if (hashlist_mode == HL_MODE_ARG)
10911 {
10912 char *input_buf = myargv[optind];
10913
10914 uint input_len = strlen (input_buf);
10915
10916 logfile_top_var_string ("target", input_buf);
10917
10918 char *hash_buf = NULL;
10919 int hash_len = 0;
10920
10921 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10922
10923 if (hash_len)
10924 {
10925 if (opts_type & OPTS_TYPE_HASH_COPY)
10926 {
10927 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10928
10929 hash_info_tmp->orighash = mystrdup (hash_buf);
10930 }
10931
10932 if (isSalted)
10933 {
10934 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10935 }
10936
10937 int parser_status = PARSER_OK;
10938
10939 if (hash_mode == 2500)
10940 {
10941 if (hash_len == 0)
10942 {
10943 log_error ("ERROR: hccap file not specified");
10944
10945 return (-1);
10946 }
10947
10948 hashlist_mode = HL_MODE_FILE;
10949
10950 data.hashlist_mode = hashlist_mode;
10951
10952 FILE *fp = fopen (hash_buf, "rb");
10953
10954 if (fp == NULL)
10955 {
10956 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10957
10958 return (-1);
10959 }
10960
10961 if (hashes_avail < 1)
10962 {
10963 log_error ("ERROR: hccap file is empty or corrupt");
10964
10965 fclose (fp);
10966
10967 return (-1);
10968 }
10969
10970 uint hccap_size = sizeof (hccap_t);
10971
10972 char *in = (char *) mymalloc (hccap_size);
10973
10974 while (!feof (fp))
10975 {
10976 int n = fread (in, hccap_size, 1, fp);
10977
10978 if (n != 1)
10979 {
10980 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10981
10982 break;
10983 }
10984
10985 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10986
10987 if (parser_status != PARSER_OK)
10988 {
10989 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10990
10991 continue;
10992 }
10993
10994 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10995
10996 if ((show == 1) || (left == 1))
10997 {
10998 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10999
11000 char *salt_ptr = (char *) tmp_salt->salt_buf;
11001
11002 int cur_pos = tmp_salt->salt_len;
11003 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11004
11005 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11006
11007 u8 *pke_ptr = (u8 *) wpa->pke;
11008
11009 // do the appending task
11010
11011 snprintf (salt_ptr + cur_pos,
11012 rem_len,
11013 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11014 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
11015 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
11016
11017
11018 // memset () the remaining part of the salt
11019
11020 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11021 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11022
11023 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11024
11025 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11026 }
11027
11028 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);
11029 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);
11030
11031 hashes_cnt++;
11032 }
11033
11034 fclose (fp);
11035
11036 myfree (in);
11037 }
11038 else if (hash_mode == 3000)
11039 {
11040 if (hash_len == 32)
11041 {
11042 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11043
11044 hash_t *lm_hash_left = NULL;
11045
11046 if (parser_status == PARSER_OK)
11047 {
11048 lm_hash_left = &hashes_buf[hashes_cnt];
11049
11050 hashes_cnt++;
11051 }
11052 else
11053 {
11054 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11055 }
11056
11057 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11058
11059 hash_t *lm_hash_right = NULL;
11060
11061 if (parser_status == PARSER_OK)
11062 {
11063 lm_hash_right = &hashes_buf[hashes_cnt];
11064
11065 hashes_cnt++;
11066 }
11067 else
11068 {
11069 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11070 }
11071
11072 // show / left
11073
11074 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11075 {
11076 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);
11077 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);
11078 }
11079 }
11080 else
11081 {
11082 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11083
11084 if (parser_status == PARSER_OK)
11085 {
11086 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11087 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11088 }
11089
11090 if (parser_status == PARSER_OK)
11091 {
11092 hashes_cnt++;
11093 }
11094 else
11095 {
11096 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11097 }
11098 }
11099 }
11100 else
11101 {
11102 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11103
11104 if (parser_status == PARSER_OK)
11105 {
11106 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11107 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11108 }
11109
11110 if (parser_status == PARSER_OK)
11111 {
11112 hashes_cnt++;
11113 }
11114 else
11115 {
11116 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11117 }
11118 }
11119 }
11120 }
11121 else if (hashlist_mode == HL_MODE_FILE)
11122 {
11123 char *hashfile = data.hashfile;
11124
11125 FILE *fp;
11126
11127 if ((fp = fopen (hashfile, "rb")) == NULL)
11128 {
11129 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11130
11131 return (-1);
11132 }
11133
11134 uint line_num = 0;
11135
11136 while (!feof (fp))
11137 {
11138 line_num++;
11139
11140 char line_buf[BUFSIZ] = { 0 };
11141
11142 int line_len = fgetl (fp, line_buf);
11143
11144 if (line_len == 0) continue;
11145
11146 char *hash_buf = NULL;
11147 int hash_len = 0;
11148
11149 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11150
11151 if (username)
11152 {
11153 char *user_buf = NULL;
11154 int user_len = 0;
11155
11156 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11157
11158 if (remove || show)
11159 {
11160 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11161
11162 *user = (user_t *) mymalloc (sizeof (user_t));
11163
11164 user_t *user_ptr = *user;
11165
11166 if (user_buf != NULL)
11167 {
11168 user_ptr->user_name = mystrdup (user_buf);
11169 }
11170 else
11171 {
11172 user_ptr->user_name = mystrdup ("");
11173 }
11174
11175 user_ptr->user_len = user_len;
11176 }
11177 }
11178
11179 if (opts_type & OPTS_TYPE_HASH_COPY)
11180 {
11181 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11182
11183 hash_info_tmp->orighash = mystrdup (hash_buf);
11184 }
11185
11186 if (isSalted)
11187 {
11188 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11189 }
11190
11191 if (hash_mode == 3000)
11192 {
11193 if (hash_len == 32)
11194 {
11195 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11196
11197 if (parser_status < PARSER_GLOBAL_ZERO)
11198 {
11199 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11200
11201 continue;
11202 }
11203
11204 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11205
11206 hashes_cnt++;
11207
11208 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11209
11210 if (parser_status < PARSER_GLOBAL_ZERO)
11211 {
11212 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11213
11214 continue;
11215 }
11216
11217 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11218
11219 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);
11220
11221 hashes_cnt++;
11222
11223 // show / left
11224
11225 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);
11226 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);
11227 }
11228 else
11229 {
11230 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11231
11232 if (parser_status < PARSER_GLOBAL_ZERO)
11233 {
11234 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11235
11236 continue;
11237 }
11238
11239 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);
11240
11241 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11242 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11243
11244 hashes_cnt++;
11245 }
11246 }
11247 else
11248 {
11249 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11250
11251 if (parser_status < PARSER_GLOBAL_ZERO)
11252 {
11253 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11254
11255 continue;
11256 }
11257
11258 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);
11259
11260 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11261 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11262
11263 hashes_cnt++;
11264 }
11265 }
11266
11267 fclose (fp);
11268
11269 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11270
11271 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11272 }
11273 }
11274 else
11275 {
11276 if (isSalted)
11277 {
11278 hashes_buf[0].salt->salt_len = 8;
11279
11280 // special salt handling
11281
11282 switch (hash_mode)
11283 {
11284 case 1500: hashes_buf[0].salt->salt_len = 2;
11285 break;
11286 case 1731: hashes_buf[0].salt->salt_len = 4;
11287 break;
11288 case 2410: hashes_buf[0].salt->salt_len = 4;
11289 break;
11290 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11291 break;
11292 case 3100: hashes_buf[0].salt->salt_len = 1;
11293 break;
11294 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11295 break;
11296 case 5800: hashes_buf[0].salt->salt_len = 16;
11297 break;
11298 case 6800: hashes_buf[0].salt->salt_len = 32;
11299 break;
11300 case 8400: hashes_buf[0].salt->salt_len = 40;
11301 break;
11302 case 8800: hashes_buf[0].salt->salt_len = 16;
11303 break;
11304 case 8900: hashes_buf[0].salt->salt_len = 16;
11305 hashes_buf[0].salt->scrypt_N = 1024;
11306 hashes_buf[0].salt->scrypt_r = 1;
11307 hashes_buf[0].salt->scrypt_p = 1;
11308 break;
11309 case 9100: hashes_buf[0].salt->salt_len = 16;
11310 break;
11311 case 9300: hashes_buf[0].salt->salt_len = 14;
11312 hashes_buf[0].salt->scrypt_N = 16384;
11313 hashes_buf[0].salt->scrypt_r = 1;
11314 hashes_buf[0].salt->scrypt_p = 1;
11315 break;
11316 case 9400: hashes_buf[0].salt->salt_len = 16;
11317 break;
11318 case 9500: hashes_buf[0].salt->salt_len = 16;
11319 break;
11320 case 9600: hashes_buf[0].salt->salt_len = 16;
11321 break;
11322 case 9700: hashes_buf[0].salt->salt_len = 16;
11323 break;
11324 case 9710: hashes_buf[0].salt->salt_len = 16;
11325 break;
11326 case 9720: hashes_buf[0].salt->salt_len = 16;
11327 break;
11328 case 9800: hashes_buf[0].salt->salt_len = 16;
11329 break;
11330 case 9810: hashes_buf[0].salt->salt_len = 16;
11331 break;
11332 case 9820: hashes_buf[0].salt->salt_len = 16;
11333 break;
11334 case 10300: hashes_buf[0].salt->salt_len = 12;
11335 break;
11336 case 11500: hashes_buf[0].salt->salt_len = 4;
11337 break;
11338 case 11600: hashes_buf[0].salt->salt_len = 4;
11339 break;
11340 case 12400: hashes_buf[0].salt->salt_len = 4;
11341 break;
11342 case 12500: hashes_buf[0].salt->salt_len = 8;
11343 break;
11344 case 12600: hashes_buf[0].salt->salt_len = 64;
11345 break;
11346 }
11347
11348 // special esalt handling
11349
11350 switch (hash_mode)
11351 {
11352 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11353 break;
11354 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11355 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11356 break;
11357 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11358 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11359 break;
11360 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11361 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11362 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11363 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11364 break;
11365 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11366 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11367 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11368 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11369 break;
11370 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11371 break;
11372 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11373 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11374 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11375 break;
11376 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11377 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11378 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11379 break;
11380 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11381 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11382 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11383 break;
11384 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11385 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11386 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11387 break;
11388 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11389 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11390 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11391 break;
11392 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11393 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11394 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11395 break;
11396 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11397 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11398 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11399 break;
11400 }
11401 }
11402
11403 // set hashfile
11404
11405 switch (hash_mode)
11406 {
11407 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11408 break;
11409 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11410 break;
11411 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11412 break;
11413 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11414 break;
11415 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11416 break;
11417 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11418 break;
11419 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11420 break;
11421 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11422 break;
11423 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11424 break;
11425 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11426 break;
11427 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11428 break;
11429 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11430 break;
11431 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11432 break;
11433 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11434 break;
11435 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11436 break;
11437 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11438 break;
11439 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11440 break;
11441 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11442 break;
11443 }
11444
11445 // set default iterations
11446
11447 switch (hash_mode)
11448 {
11449 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11450 break;
11451 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11452 break;
11453 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11454 break;
11455 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11456 break;
11457 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11458 break;
11459 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11460 break;
11461 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11462 break;
11463 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11464 break;
11465 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11466 break;
11467 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11468 break;
11469 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11470 break;
11471 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11472 break;
11473 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11474 break;
11475 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11476 break;
11477 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11478 break;
11479 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11480 break;
11481 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11482 break;
11483 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11484 break;
11485 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11486 break;
11487 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11488 break;
11489 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11490 break;
11491 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11492 break;
11493 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11494 break;
11495 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11496 break;
11497 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11498 break;
11499 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11500 break;
11501 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11502 break;
11503 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11504 break;
11505 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11506 break;
11507 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11508 break;
11509 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11510 break;
11511 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11512 break;
11513 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11514 break;
11515 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11516 break;
11517 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11518 break;
11519 case 8900: hashes_buf[0].salt->salt_iter = 1;
11520 break;
11521 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11522 break;
11523 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11524 break;
11525 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11526 break;
11527 case 9300: hashes_buf[0].salt->salt_iter = 1;
11528 break;
11529 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11530 break;
11531 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11532 break;
11533 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11534 break;
11535 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11536 break;
11537 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11538 break;
11539 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11540 break;
11541 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11542 break;
11543 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11544 break;
11545 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11546 break;
11547 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11548 break;
11549 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11550 break;
11551 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11552 break;
11553 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11554 break;
11555 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11556 break;
11557 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11558 break;
11559 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11560 break;
11561 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11562 break;
11563 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11564 break;
11565 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11566 break;
11567 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11568 break;
11569 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11570 break;
11571 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11572 break;
11573 }
11574
11575 hashes_cnt = 1;
11576 }
11577
11578 if (show == 1 || left == 1)
11579 {
11580 for (uint i = 0; i < pot_cnt; i++)
11581 {
11582 pot_t *pot_ptr = &pot[i];
11583
11584 hash_t *hashes_buf = &pot_ptr->hash;
11585
11586 local_free (hashes_buf->digest);
11587
11588 if (isSalted)
11589 {
11590 local_free (hashes_buf->salt);
11591 }
11592 }
11593
11594 local_free (pot);
11595
11596 if (data.quiet == 0) log_info_nn ("");
11597
11598 return (0);
11599 }
11600
11601 if (keyspace == 0)
11602 {
11603 if (hashes_cnt == 0)
11604 {
11605 log_error ("ERROR: No hashes loaded");
11606
11607 return (-1);
11608 }
11609 }
11610
11611 /**
11612 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11613 */
11614
11615 if (data.outfile != NULL)
11616 {
11617 if (data.hashfile != NULL)
11618 {
11619 #ifdef _POSIX
11620 struct stat tmpstat_outfile;
11621 struct stat tmpstat_hashfile;
11622 #endif
11623
11624 #ifdef _WIN
11625 struct stat64 tmpstat_outfile;
11626 struct stat64 tmpstat_hashfile;
11627 #endif
11628
11629 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11630
11631 if (tmp_outfile_fp)
11632 {
11633 #ifdef _POSIX
11634 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11635 #endif
11636
11637 #ifdef _WIN
11638 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11639 #endif
11640
11641 fclose (tmp_outfile_fp);
11642 }
11643
11644 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11645
11646 if (tmp_hashfile_fp)
11647 {
11648 #ifdef _POSIX
11649 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11650 #endif
11651
11652 #ifdef _WIN
11653 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11654 #endif
11655
11656 fclose (tmp_hashfile_fp);
11657 }
11658
11659 if (tmp_outfile_fp && tmp_outfile_fp)
11660 {
11661 tmpstat_outfile.st_mode = 0;
11662 tmpstat_outfile.st_nlink = 0;
11663 tmpstat_outfile.st_uid = 0;
11664 tmpstat_outfile.st_gid = 0;
11665 tmpstat_outfile.st_rdev = 0;
11666 tmpstat_outfile.st_atime = 0;
11667
11668 tmpstat_hashfile.st_mode = 0;
11669 tmpstat_hashfile.st_nlink = 0;
11670 tmpstat_hashfile.st_uid = 0;
11671 tmpstat_hashfile.st_gid = 0;
11672 tmpstat_hashfile.st_rdev = 0;
11673 tmpstat_hashfile.st_atime = 0;
11674
11675 #ifdef _POSIX
11676 tmpstat_outfile.st_blksize = 0;
11677 tmpstat_outfile.st_blocks = 0;
11678
11679 tmpstat_hashfile.st_blksize = 0;
11680 tmpstat_hashfile.st_blocks = 0;
11681 #endif
11682
11683 #ifdef _POSIX
11684 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11685 {
11686 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11687
11688 return (-1);
11689 }
11690 #endif
11691
11692 #ifdef _WIN
11693 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11694 {
11695 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11696
11697 return (-1);
11698 }
11699 #endif
11700 }
11701 }
11702 }
11703
11704 /**
11705 * Remove duplicates
11706 */
11707
11708 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11709
11710 if (isSalted)
11711 {
11712 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11713 }
11714 else
11715 {
11716 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11717 }
11718
11719 uint hashes_cnt_orig = hashes_cnt;
11720
11721 hashes_cnt = 1;
11722
11723 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11724 {
11725 if (isSalted)
11726 {
11727 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11728 {
11729 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11730 }
11731 }
11732 else
11733 {
11734 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11735 }
11736
11737 if (hashes_pos > hashes_cnt)
11738 {
11739 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11740 }
11741
11742 hashes_cnt++;
11743 }
11744
11745 /**
11746 * Potfile removes
11747 */
11748
11749 uint potfile_remove_cracks = 0;
11750
11751 if (potfile_disable == 0)
11752 {
11753 hash_t hash_buf;
11754
11755 hash_buf.digest = mymalloc (dgst_size);
11756 hash_buf.salt = NULL;
11757 hash_buf.esalt = NULL;
11758 hash_buf.hash_info = NULL;
11759 hash_buf.cracked = 0;
11760
11761 if (isSalted)
11762 {
11763 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11764 }
11765
11766 if (esalt_size)
11767 {
11768 hash_buf.esalt = mymalloc (esalt_size);
11769 }
11770
11771 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11772
11773 // no solution for these special hash types (for instane because they use hashfile in output etc)
11774 if ((hash_mode != 5200) &&
11775 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11776 (hash_mode != 9000))
11777 {
11778 FILE *fp = fopen (potfile, "rb");
11779
11780 if (fp != NULL)
11781 {
11782 while (!feof (fp))
11783 {
11784 char line_buf[BUFSIZ] = { 0 };
11785
11786 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11787
11788 if (ptr == NULL) break;
11789
11790 int line_len = strlen (line_buf);
11791
11792 if (line_len == 0) continue;
11793
11794 int iter = MAX_CUT_TRIES;
11795
11796 for (int i = line_len - 1; i && iter; i--, line_len--)
11797 {
11798 if (line_buf[i] != ':') continue;
11799
11800 if (isSalted)
11801 {
11802 memset (hash_buf.salt, 0, sizeof (salt_t));
11803 }
11804
11805 hash_t *found = NULL;
11806
11807 if (hash_mode == 6800)
11808 {
11809 if (i < 64) // 64 = 16 * uint in salt_buf[]
11810 {
11811 // manipulate salt_buf
11812 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11813
11814 hash_buf.salt->salt_len = i;
11815
11816 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11817 }
11818 }
11819 else if (hash_mode == 2500)
11820 {
11821 if (i < 64) // 64 = 16 * uint in salt_buf[]
11822 {
11823 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11824 // manipulate salt_buf
11825
11826 // to be safe work with a copy (because of line_len loop, i etc)
11827
11828 char line_buf_cpy[BUFSIZ] = { 0 };
11829
11830 memcpy (line_buf_cpy, line_buf, i);
11831
11832 char *mac2_pos = strrchr (line_buf_cpy, ':');
11833
11834 if (mac2_pos == NULL) continue;
11835
11836 mac2_pos[0] = 0;
11837 mac2_pos++;
11838
11839 if (strlen (mac2_pos) != 12) continue;
11840
11841 char *mac1_pos = strrchr (line_buf_cpy, ':');
11842
11843 if (mac1_pos == NULL) continue;
11844
11845 mac1_pos[0] = 0;
11846 mac1_pos++;
11847
11848 if (strlen (mac1_pos) != 12) continue;
11849
11850 uint essid_length = mac1_pos - line_buf_cpy - 1;
11851
11852 // here we need the ESSID
11853 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11854
11855 hash_buf.salt->salt_len = essid_length;
11856
11857 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11858
11859 if (found)
11860 {
11861 wpa_t *wpa = (wpa_t *) found->esalt;
11862
11863 uint pke[25] = { 0 };
11864
11865 char *pke_ptr = (char *) pke;
11866
11867 for (uint i = 0; i < 25; i++)
11868 {
11869 pke[i] = byte_swap_32 (wpa->pke[i]);
11870 }
11871
11872 u8 mac1[6] = { 0 };
11873 u8 mac2[6] = { 0 };
11874
11875 memcpy (mac1, pke_ptr + 23, 6);
11876 memcpy (mac2, pke_ptr + 29, 6);
11877
11878 // compare hex string(s) vs binary MAC address(es)
11879
11880 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11881 {
11882 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11883 {
11884 found = NULL;
11885 break;
11886 }
11887 }
11888
11889 // early skip ;)
11890 if (!found) continue;
11891
11892 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11893 {
11894 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11895 {
11896 found = NULL;
11897 break;
11898 }
11899 }
11900 }
11901 }
11902 }
11903 else
11904 {
11905 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11906
11907 if (parser_status == PARSER_OK)
11908 {
11909 if (isSalted)
11910 {
11911 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11912 }
11913 else
11914 {
11915 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11916 }
11917 }
11918 }
11919
11920 if (found == NULL) continue;
11921
11922 if (!found->cracked) potfile_remove_cracks++;
11923
11924 found->cracked = 1;
11925
11926 if (found) break;
11927
11928 iter--;
11929 }
11930 }
11931
11932 fclose (fp);
11933 }
11934 }
11935
11936 if (esalt_size)
11937 {
11938 local_free (hash_buf.esalt);
11939 }
11940
11941 if (isSalted)
11942 {
11943 local_free (hash_buf.salt);
11944 }
11945
11946 local_free (hash_buf.digest);
11947 }
11948
11949 /**
11950 * Now generate all the buffers required for later
11951 */
11952
11953 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11954
11955 salt_t *salts_buf_new = NULL;
11956 void *esalts_buf_new = NULL;
11957
11958 if (isSalted)
11959 {
11960 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11961
11962 if (esalt_size)
11963 {
11964 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11965 }
11966 }
11967 else
11968 {
11969 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11970 }
11971
11972 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11973
11974 uint digests_cnt = hashes_cnt;
11975 uint digests_done = 0;
11976
11977 uint size_digests = digests_cnt * dgst_size;
11978 uint size_shown = digests_cnt * sizeof (uint);
11979
11980 uint *digests_shown = (uint *) mymalloc (size_shown);
11981 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11982
11983 uint salts_cnt = 0;
11984 uint salts_done = 0;
11985
11986 hashinfo_t **hash_info = NULL;
11987
11988 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11989 {
11990 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11991
11992 if (username && (remove || show))
11993 {
11994 uint user_pos;
11995
11996 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11997 {
11998 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11999
12000 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12001 }
12002 }
12003 }
12004
12005 uint *salts_shown = (uint *) mymalloc (size_shown);
12006
12007 salt_t *salt_buf;
12008
12009 {
12010 // copied from inner loop
12011
12012 salt_buf = &salts_buf_new[salts_cnt];
12013
12014 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12015
12016 if (esalt_size)
12017 {
12018 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12019 }
12020
12021 salt_buf->digests_cnt = 0;
12022 salt_buf->digests_done = 0;
12023 salt_buf->digests_offset = 0;
12024
12025 salts_cnt++;
12026 }
12027
12028 if (hashes_buf[0].cracked == 1)
12029 {
12030 digests_shown[0] = 1;
12031
12032 digests_done++;
12033
12034 salt_buf->digests_done++;
12035 }
12036
12037 salt_buf->digests_cnt++;
12038
12039 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12040
12041 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12042 {
12043 hash_info[0] = hashes_buf[0].hash_info;
12044 }
12045
12046 // copy from inner loop
12047
12048 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12049 {
12050 if (isSalted)
12051 {
12052 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12053 {
12054 salt_buf = &salts_buf_new[salts_cnt];
12055
12056 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12057
12058 if (esalt_size)
12059 {
12060 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12061 }
12062
12063 salt_buf->digests_cnt = 0;
12064 salt_buf->digests_done = 0;
12065 salt_buf->digests_offset = hashes_pos;
12066
12067 salts_cnt++;
12068 }
12069 }
12070
12071 if (hashes_buf[hashes_pos].cracked == 1)
12072 {
12073 digests_shown[hashes_pos] = 1;
12074
12075 digests_done++;
12076
12077 salt_buf->digests_done++;
12078 }
12079
12080 salt_buf->digests_cnt++;
12081
12082 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12083
12084 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12085 {
12086 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12087 }
12088 }
12089
12090 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12091 {
12092 salt_t *salt_buf = &salts_buf_new[salt_pos];
12093
12094 if (salt_buf->digests_done == salt_buf->digests_cnt)
12095 {
12096 salts_shown[salt_pos] = 1;
12097
12098 salts_done++;
12099 }
12100
12101 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12102 }
12103
12104 local_free (digests_buf);
12105 local_free (salts_buf);
12106 local_free (esalts_buf);
12107
12108 digests_buf = digests_buf_new;
12109 salts_buf = salts_buf_new;
12110 esalts_buf = esalts_buf_new;
12111
12112 local_free (hashes_buf);
12113
12114 /**
12115 * special modification not set from parser
12116 */
12117
12118 switch (hash_mode)
12119 {
12120 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12121 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12122 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12123 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12124 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12125 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12126 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12127 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12128 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12129 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12130 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12131 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12132 }
12133
12134 if (truecrypt_keyfiles)
12135 {
12136 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12137
12138 char *keyfiles = strdup (truecrypt_keyfiles);
12139
12140 char *keyfile = strtok (keyfiles, ",");
12141
12142 do
12143 {
12144 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12145
12146 } while ((keyfile = strtok (NULL, ",")) != NULL);
12147
12148 free (keyfiles);
12149 }
12150
12151 data.digests_cnt = digests_cnt;
12152 data.digests_done = digests_done;
12153 data.digests_buf = digests_buf;
12154 data.digests_shown = digests_shown;
12155 data.digests_shown_tmp = digests_shown_tmp;
12156
12157 data.salts_cnt = salts_cnt;
12158 data.salts_done = salts_done;
12159 data.salts_buf = salts_buf;
12160 data.salts_shown = salts_shown;
12161
12162 data.esalts_buf = esalts_buf;
12163 data.hash_info = hash_info;
12164
12165 /**
12166 * Automatic Optimizers
12167 */
12168
12169 if (salts_cnt == 1)
12170 opti_type |= OPTI_TYPE_SINGLE_SALT;
12171
12172 if (digests_cnt == 1)
12173 opti_type |= OPTI_TYPE_SINGLE_HASH;
12174
12175 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12176 opti_type |= OPTI_TYPE_NOT_ITERATED;
12177
12178 if (attack_mode == ATTACK_MODE_BF)
12179 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12180
12181 data.opti_type = opti_type;
12182
12183 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12184 {
12185 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12186 {
12187 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12188 {
12189 if (opts_type & OPTS_TYPE_ST_ADD80)
12190 {
12191 opts_type &= ~OPTS_TYPE_ST_ADD80;
12192 opts_type |= OPTS_TYPE_PT_ADD80;
12193 }
12194
12195 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12196 {
12197 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12198 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12199 }
12200
12201 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12202 {
12203 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12204 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12205 }
12206 }
12207 }
12208 }
12209
12210 /**
12211 * Some algorithm, like descrypt, can benefit from JIT compilation
12212 */
12213
12214 int force_jit_compilation = -1;
12215
12216 if (hash_mode == 8900)
12217 {
12218 force_jit_compilation = 8900;
12219 }
12220 else if (hash_mode == 9300)
12221 {
12222 force_jit_compilation = 8900;
12223 }
12224 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12225 {
12226 force_jit_compilation = 1500;
12227 }
12228
12229 /**
12230 * generate bitmap tables
12231 */
12232
12233 const uint bitmap_shift1 = 5;
12234 const uint bitmap_shift2 = 13;
12235
12236 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12237
12238 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12239 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12240 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12241 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12242 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12243 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12244 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12245 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12246
12247 uint bitmap_bits;
12248 uint bitmap_nums;
12249 uint bitmap_mask;
12250 uint bitmap_size;
12251
12252 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12253 {
12254 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12255
12256 bitmap_nums = 1 << bitmap_bits;
12257
12258 bitmap_mask = bitmap_nums - 1;
12259
12260 bitmap_size = bitmap_nums * sizeof (uint);
12261
12262 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12263
12264 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;
12265 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;
12266
12267 break;
12268 }
12269
12270 bitmap_nums = 1 << bitmap_bits;
12271
12272 bitmap_mask = bitmap_nums - 1;
12273
12274 bitmap_size = bitmap_nums * sizeof (uint);
12275
12276 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);
12277 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);
12278
12279 /**
12280 * prepare quick rule
12281 */
12282
12283 data.rule_buf_l = rule_buf_l;
12284 data.rule_buf_r = rule_buf_r;
12285
12286 int rule_len_l = (int) strlen (rule_buf_l);
12287 int rule_len_r = (int) strlen (rule_buf_r);
12288
12289 data.rule_len_l = rule_len_l;
12290 data.rule_len_r = rule_len_r;
12291
12292 /**
12293 * load rules
12294 */
12295
12296 uint *all_kernel_rules_cnt = NULL;
12297
12298 kernel_rule_t **all_kernel_rules_buf = NULL;
12299
12300 if (rp_files_cnt)
12301 {
12302 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12303
12304 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12305 }
12306
12307 char rule_buf[BUFSIZ] = { 0 };
12308
12309 int rule_len = 0;
12310
12311 for (uint i = 0; i < rp_files_cnt; i++)
12312 {
12313 uint kernel_rules_avail = 0;
12314
12315 uint kernel_rules_cnt = 0;
12316
12317 kernel_rule_t *kernel_rules_buf = NULL;
12318
12319 char *rp_file = rp_files[i];
12320
12321 char in[BLOCK_SIZE] = { 0 };
12322 char out[BLOCK_SIZE] = { 0 };
12323
12324 FILE *fp = NULL;
12325
12326 uint rule_line = 0;
12327
12328 if ((fp = fopen (rp_file, "rb")) == NULL)
12329 {
12330 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12331
12332 return (-1);
12333 }
12334
12335 while (!feof (fp))
12336 {
12337 memset (rule_buf, 0, BUFSIZ);
12338
12339 rule_len = fgetl (fp, rule_buf);
12340
12341 rule_line++;
12342
12343 if (rule_len == 0) continue;
12344
12345 if (rule_buf[0] == '#') continue;
12346
12347 if (kernel_rules_avail == kernel_rules_cnt)
12348 {
12349 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12350
12351 kernel_rules_avail += INCR_RULES;
12352 }
12353
12354 memset (in, 0, BLOCK_SIZE);
12355 memset (out, 0, BLOCK_SIZE);
12356
12357 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12358
12359 if (result == -1)
12360 {
12361 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12362
12363 continue;
12364 }
12365
12366 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12367 {
12368 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12369
12370 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12371
12372 continue;
12373 }
12374
12375 /* its so slow
12376 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12377 {
12378 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12379
12380 continue;
12381 }
12382 */
12383
12384 kernel_rules_cnt++;
12385 }
12386
12387 fclose (fp);
12388
12389 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12390
12391 all_kernel_rules_buf[i] = kernel_rules_buf;
12392 }
12393
12394 /**
12395 * merge rules or automatic rule generator
12396 */
12397
12398 uint kernel_rules_cnt = 0;
12399
12400 kernel_rule_t *kernel_rules_buf = NULL;
12401
12402 if (attack_mode == ATTACK_MODE_STRAIGHT)
12403 {
12404 if (rp_files_cnt)
12405 {
12406 kernel_rules_cnt = 1;
12407
12408 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12409
12410 repeats[0] = kernel_rules_cnt;
12411
12412 for (uint i = 0; i < rp_files_cnt; i++)
12413 {
12414 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12415
12416 repeats[i + 1] = kernel_rules_cnt;
12417 }
12418
12419 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12420
12421 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12422
12423 for (uint i = 0; i < kernel_rules_cnt; i++)
12424 {
12425 uint out_pos = 0;
12426
12427 kernel_rule_t *out = &kernel_rules_buf[i];
12428
12429 for (uint j = 0; j < rp_files_cnt; j++)
12430 {
12431 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12432 uint in_pos;
12433
12434 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12435
12436 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12437 {
12438 if (out_pos == RULES_MAX - 1)
12439 {
12440 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12441
12442 break;
12443 }
12444
12445 out->cmds[out_pos] = in->cmds[in_pos];
12446 }
12447 }
12448 }
12449
12450 local_free (repeats);
12451 }
12452 else if (rp_gen)
12453 {
12454 uint kernel_rules_avail = 0;
12455
12456 while (kernel_rules_cnt < rp_gen)
12457 {
12458 if (kernel_rules_avail == kernel_rules_cnt)
12459 {
12460 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12461
12462 kernel_rules_avail += INCR_RULES;
12463 }
12464
12465 memset (rule_buf, 0, BLOCK_SIZE);
12466
12467 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12468
12469 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12470
12471 kernel_rules_cnt++;
12472 }
12473 }
12474 }
12475
12476 /**
12477 * generate NOP rules
12478 */
12479
12480 if (kernel_rules_cnt == 0)
12481 {
12482 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12483
12484 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12485
12486 kernel_rules_cnt++;
12487 }
12488
12489 data.kernel_rules_cnt = kernel_rules_cnt;
12490 data.kernel_rules_buf = kernel_rules_buf;
12491
12492 /**
12493 * OpenCL platforms: detect
12494 */
12495
12496 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12497 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12498
12499 cl_uint platforms_cnt = 0;
12500 cl_uint platform_devices_cnt = 0;
12501
12502 if (keyspace == 0)
12503 {
12504 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12505
12506 if (platforms_cnt == 0)
12507 {
12508 log_error ("ERROR: No OpenCL compatible platform found");
12509
12510 return (-1);
12511 }
12512
12513 if (opencl_platforms_filter != (uint) -1)
12514 {
12515 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12516
12517 if (opencl_platforms_filter > platform_cnt_mask)
12518 {
12519 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12520
12521 return (-1);
12522 }
12523 }
12524 }
12525
12526 /**
12527 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12528 */
12529
12530 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12531 {
12532 cl_platform_id platform = platforms[platform_id];
12533
12534 char platform_vendor[INFOSZ] = { 0 };
12535
12536 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12537
12538 #ifdef HAVE_HWMON
12539 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12540 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12541 {
12542 // make sure that we do not directly control the fan for NVidia
12543
12544 gpu_temp_retain = 0;
12545
12546 data.gpu_temp_retain = gpu_temp_retain;
12547 }
12548 #endif // HAVE_NVML || HAVE_NVAPI
12549 #endif
12550 }
12551
12552 /**
12553 * OpenCL devices: simply push all devices from all platforms into the same device array
12554 */
12555
12556 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12557
12558 data.devices_param = devices_param;
12559
12560 uint devices_cnt = 0;
12561
12562 uint devices_active = 0;
12563
12564 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12565 {
12566 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12567
12568 cl_platform_id platform = platforms[platform_id];
12569
12570 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12571
12572 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12573 {
12574 size_t param_value_size = 0;
12575
12576 const uint device_id = devices_cnt;
12577
12578 hc_device_param_t *device_param = &data.devices_param[device_id];
12579
12580 device_param->device = platform_devices[platform_devices_id];
12581
12582 device_param->device_id = device_id;
12583
12584 device_param->platform_devices_id = platform_devices_id;
12585
12586 // device_type
12587
12588 cl_device_type device_type;
12589
12590 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12591
12592 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12593
12594 device_param->device_type = device_type;
12595
12596 // vendor_id
12597
12598 cl_uint vendor_id = 0;
12599
12600 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12601
12602 device_param->vendor_id = vendor_id;
12603
12604 // device_name
12605
12606 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12607
12608 char *device_name = (char *) mymalloc (param_value_size);
12609
12610 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12611
12612 device_param->device_name = device_name;
12613
12614 // tuning db
12615
12616 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12617
12618 // device_version
12619
12620 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12621
12622 char *device_version = (char *) mymalloc (param_value_size);
12623
12624 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12625
12626 device_param->device_version = device_version;
12627
12628 // device_opencl_version
12629
12630 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12631
12632 char *device_opencl_version = (char *) mymalloc (param_value_size);
12633
12634 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12635
12636 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12637
12638 myfree (device_opencl_version);
12639
12640 if (strstr (device_version, "pocl"))
12641 {
12642 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12643 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12644
12645 cl_uint vendor_id = VENDOR_ID_GENERIC;
12646
12647 device_param->vendor_id = vendor_id;
12648 }
12649
12650 // vector_width
12651
12652 cl_uint vector_width;
12653
12654 if (opencl_vector_width_chgd == 0)
12655 {
12656 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12657 {
12658 if (opti_type & OPTI_TYPE_USES_BITS_64)
12659 {
12660 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12661 }
12662 else
12663 {
12664 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12665 }
12666 }
12667 else
12668 {
12669 vector_width = (cl_uint) tuningdb_entry->vector_width;
12670 }
12671 }
12672 else
12673 {
12674 vector_width = opencl_vector_width;
12675 }
12676
12677 if (vector_width > 16) vector_width = 16;
12678
12679 device_param->vector_width = vector_width;
12680
12681 // max_compute_units
12682
12683 cl_uint device_processors;
12684
12685 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12686
12687 device_param->device_processors = device_processors;
12688
12689 // max_mem_alloc_size
12690
12691 cl_ulong device_maxmem_alloc;
12692
12693 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12694
12695 device_param->device_maxmem_alloc = device_maxmem_alloc;
12696
12697 // max_mem_alloc_size
12698
12699 cl_ulong device_global_mem;
12700
12701 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12702
12703 device_param->device_global_mem = device_global_mem;
12704
12705 // max_clock_frequency
12706
12707 cl_uint device_maxclock_frequency;
12708
12709 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12710
12711 device_param->device_maxclock_frequency = device_maxclock_frequency;
12712
12713 // skipped
12714
12715 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12716 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12717
12718 device_param->skipped = (skipped1 || skipped2);
12719
12720 // driver_version
12721 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12722
12723 char *driver_version = (char *) mymalloc (param_value_size);
12724
12725 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12726
12727 device_param->driver_version = driver_version;
12728
12729 // device_name_chksum
12730
12731 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12732
12733 #if __x86_64__
12734 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);
12735 #else
12736 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);
12737 #endif
12738
12739 uint device_name_digest[4] = { 0 };
12740
12741 md5_64 ((uint *) device_name_chksum, device_name_digest);
12742
12743 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12744
12745 device_param->device_name_chksum = device_name_chksum;
12746
12747 // device_processor_cores
12748
12749 if (device_type & CL_DEVICE_TYPE_CPU)
12750 {
12751 cl_uint device_processor_cores = 1;
12752
12753 device_param->device_processor_cores = device_processor_cores;
12754 }
12755
12756 if (device_type & CL_DEVICE_TYPE_GPU)
12757 {
12758 if (vendor_id == VENDOR_ID_AMD)
12759 {
12760 cl_uint device_processor_cores = 0;
12761
12762 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12763
12764 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12765
12766 device_param->device_processor_cores = device_processor_cores;
12767 }
12768 else if (vendor_id == VENDOR_ID_NV)
12769 {
12770 cl_uint kernel_exec_timeout = 0;
12771
12772 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12773
12774 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12775
12776 device_param->kernel_exec_timeout = kernel_exec_timeout;
12777
12778 cl_uint device_processor_cores = 0;
12779
12780 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12781
12782 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12783
12784 device_param->device_processor_cores = device_processor_cores;
12785
12786 cl_uint sm_minor = 0;
12787 cl_uint sm_major = 0;
12788
12789 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12790 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12791
12792 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12793 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12794
12795 device_param->sm_minor = sm_minor;
12796 device_param->sm_major = sm_major;
12797 }
12798 else
12799 {
12800 cl_uint device_processor_cores = 1;
12801
12802 device_param->device_processor_cores = device_processor_cores;
12803 }
12804 }
12805
12806 // display results
12807
12808 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12809 {
12810 if (device_param->skipped == 0)
12811 {
12812 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12813 device_id + 1,
12814 device_name,
12815 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12816 (unsigned int) (device_global_mem / 1024 / 1024),
12817 (unsigned int) (device_maxclock_frequency),
12818 (unsigned int) device_processors);
12819 }
12820 else
12821 {
12822 log_info ("Device #%u: %s, skipped",
12823 device_id + 1,
12824 device_name);
12825 }
12826 }
12827
12828 // common driver check
12829
12830 if (device_param->skipped == 0)
12831 {
12832 if (strstr (device_version, "pocl"))
12833 {
12834 if (force == 0)
12835 {
12836 log_info ("");
12837 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12838 log_info ("You are STRONGLY encouraged not to use it");
12839 log_info ("You can use --force to override this but do not post error reports if you do so");
12840 log_info ("");
12841
12842 return (-1);
12843 }
12844 }
12845
12846 if (device_type & CL_DEVICE_TYPE_GPU)
12847 {
12848 if (vendor_id == VENDOR_ID_NV)
12849 {
12850 if (device_param->kernel_exec_timeout != 0)
12851 {
12852 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);
12853 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12854 }
12855 }
12856 else if (vendor_id == VENDOR_ID_AMD)
12857 {
12858 int catalyst_check = (force == 1) ? 0 : 1;
12859
12860 int catalyst_warn = 0;
12861
12862 int catalyst_broken = 0;
12863
12864 if (catalyst_check == 1)
12865 {
12866 catalyst_warn = 1;
12867
12868 // v14.9 and higher
12869 if (atoi (device_param->driver_version) >= 1573)
12870 {
12871 catalyst_warn = 0;
12872 }
12873
12874 catalyst_check = 0;
12875 }
12876
12877 if (catalyst_broken == 1)
12878 {
12879 log_info ("");
12880 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12881 log_info ("It will pass over cracked hashes and does not report them as cracked");
12882 log_info ("You are STRONGLY encouraged not to use it");
12883 log_info ("You can use --force to override this but do not post error reports if you do so");
12884 log_info ("");
12885
12886 return (-1);
12887 }
12888
12889 if (catalyst_warn == 1)
12890 {
12891 log_info ("");
12892 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12893 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12894 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12895 #ifdef _WIN
12896 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12897 #endif
12898 log_info ("You can use --force to override this but do not post error reports if you do so");
12899 log_info ("");
12900
12901 return (-1);
12902 }
12903 }
12904 }
12905
12906 /**
12907 * kernel accel and loops tuning db adjustment
12908 */
12909
12910 device_param->kernel_accel_min = 1;
12911 device_param->kernel_accel_max = 1024;
12912
12913 device_param->kernel_loops_min = 1;
12914 device_param->kernel_loops_max = 1024;
12915
12916 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12917
12918 if (tuningdb_entry)
12919 {
12920 u32 _kernel_accel = tuningdb_entry->kernel_accel;
12921 u32 _kernel_loops = tuningdb_entry->kernel_loops;
12922
12923 if (_kernel_accel)
12924 {
12925 device_param->kernel_accel_min = _kernel_accel;
12926 device_param->kernel_accel_max = _kernel_accel;
12927 }
12928
12929 if (_kernel_loops)
12930 {
12931 if (workload_profile == 1)
12932 {
12933 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
12934 }
12935 else if (workload_profile == 2)
12936 {
12937 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
12938 }
12939
12940 device_param->kernel_loops_min = _kernel_loops;
12941 device_param->kernel_loops_max = _kernel_loops;
12942 }
12943 }
12944
12945 // commandline parameters overwrite tuningdb entries
12946
12947 if (kernel_accel)
12948 {
12949 device_param->kernel_accel_min = kernel_accel;
12950 device_param->kernel_accel_max = kernel_accel;
12951 }
12952
12953 if (kernel_loops)
12954 {
12955 device_param->kernel_loops_min = kernel_loops;
12956 device_param->kernel_loops_max = kernel_loops;
12957 }
12958
12959 /**
12960 * activate device
12961 */
12962
12963 devices_active++;
12964 }
12965
12966 // next please
12967
12968 devices_cnt++;
12969 }
12970 }
12971
12972 if (keyspace == 0 && devices_active == 0)
12973 {
12974 log_error ("ERROR: No devices found/left");
12975
12976 return (-1);
12977 }
12978
12979 // additional check to see if the user has chosen a device that is not within the range of available devices (i.e. larger than devices_cnt)
12980
12981 if (devices_filter != (uint) -1)
12982 {
12983 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
12984
12985 if (devices_filter > devices_cnt_mask)
12986 {
12987 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
12988
12989 return (-1);
12990 }
12991 }
12992
12993 data.devices_cnt = devices_cnt;
12994
12995 data.devices_active = devices_active;
12996
12997 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12998 {
12999 log_info ("");
13000 }
13001
13002 /**
13003 * HM devices: init
13004 */
13005
13006 #ifdef HAVE_HWMON
13007 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13008 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13009 #endif
13010
13011 #ifdef HAVE_ADL
13012 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13013 #endif
13014
13015 if (gpu_temp_disable == 0)
13016 {
13017 #if defined(WIN) && defined(HAVE_NVAPI)
13018 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13019
13020 if (nvapi_init (nvapi) == 0)
13021 data.hm_nv = nvapi;
13022
13023 if (data.hm_nv)
13024 {
13025 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13026 {
13027 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13028
13029 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13030
13031 int tmp_out = 0;
13032
13033 for (int i = 0; i < tmp_in; i++)
13034 {
13035 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13036 }
13037
13038 for (int i = 0; i < tmp_out; i++)
13039 {
13040 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13041
13042 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13043
13044 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;
13045 }
13046 }
13047 }
13048 #endif // WIN && HAVE_NVAPI
13049
13050 #if defined(LINUX) && defined(HAVE_NVML)
13051 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13052
13053 if (nvml_init (nvml) == 0)
13054 data.hm_nv = nvml;
13055
13056 if (data.hm_nv)
13057 {
13058 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13059 {
13060 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13061
13062 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13063
13064 int tmp_out = 0;
13065
13066 for (int i = 0; i < tmp_in; i++)
13067 {
13068 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13069 }
13070
13071 for (int i = 0; i < tmp_out; i++)
13072 {
13073 unsigned int speed;
13074
13075 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;
13076 }
13077 }
13078 }
13079 #endif // LINUX && HAVE_NVML
13080
13081 data.hm_amd = NULL;
13082
13083 #ifdef HAVE_ADL
13084 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13085
13086 if (adl_init (adl) == 0)
13087 data.hm_amd = adl;
13088
13089 if (data.hm_amd)
13090 {
13091 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13092 {
13093 // total number of adapters
13094
13095 int hm_adapters_num;
13096
13097 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13098
13099 // adapter info
13100
13101 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13102
13103 if (lpAdapterInfo == NULL) return (-1);
13104
13105 // get a list (of ids of) valid/usable adapters
13106
13107 int num_adl_adapters = 0;
13108
13109 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13110
13111 if (num_adl_adapters > 0)
13112 {
13113 hc_thread_mutex_lock (mux_adl);
13114
13115 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13116
13117 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13118
13119 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13120 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13121
13122 hc_thread_mutex_unlock (mux_adl);
13123 }
13124
13125 myfree (valid_adl_device_list);
13126 myfree (lpAdapterInfo);
13127 }
13128 }
13129 #endif // HAVE_ADL
13130
13131 if (data.hm_amd == NULL && data.hm_nv == NULL)
13132 {
13133 gpu_temp_disable = 1;
13134 }
13135 }
13136
13137 /**
13138 * OpenCL devices: allocate buffer for device specific information
13139 */
13140
13141 #ifdef HAVE_HWMON
13142 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13143
13144 #ifdef HAVE_ADL
13145 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13146
13147 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13148 #endif // ADL
13149 #endif
13150
13151 /**
13152 * enable custom signal handler(s)
13153 */
13154
13155 if (benchmark == 0)
13156 {
13157 hc_signal (sigHandler_default);
13158 }
13159 else
13160 {
13161 hc_signal (sigHandler_benchmark);
13162 }
13163
13164 /**
13165 * User-defined GPU temp handling
13166 */
13167
13168 #ifdef HAVE_HWMON
13169 if (gpu_temp_disable == 1)
13170 {
13171 gpu_temp_abort = 0;
13172 gpu_temp_retain = 0;
13173 }
13174
13175 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13176 {
13177 if (gpu_temp_abort < gpu_temp_retain)
13178 {
13179 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13180
13181 return (-1);
13182 }
13183 }
13184
13185 data.gpu_temp_disable = gpu_temp_disable;
13186 data.gpu_temp_abort = gpu_temp_abort;
13187 data.gpu_temp_retain = gpu_temp_retain;
13188 #endif
13189
13190 /**
13191 * inform the user
13192 */
13193
13194 if (data.quiet == 0)
13195 {
13196 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13197
13198 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);
13199
13200 if (attack_mode == ATTACK_MODE_STRAIGHT)
13201 {
13202 log_info ("Rules: %u", kernel_rules_cnt);
13203 }
13204
13205 if (opti_type)
13206 {
13207 log_info ("Applicable Optimizers:");
13208
13209 for (uint i = 0; i < 32; i++)
13210 {
13211 const uint opti_bit = 1u << i;
13212
13213 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13214 }
13215 }
13216
13217 /**
13218 * Watchdog and Temperature balance
13219 */
13220
13221 #ifdef HAVE_HWMON
13222 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13223 {
13224 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13225 }
13226
13227 if (gpu_temp_abort == 0)
13228 {
13229 log_info ("Watchdog: Temperature abort trigger disabled");
13230 }
13231 else
13232 {
13233 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13234 }
13235
13236 if (gpu_temp_retain == 0)
13237 {
13238 log_info ("Watchdog: Temperature retain trigger disabled");
13239 }
13240 else
13241 {
13242 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13243 }
13244 #endif
13245 }
13246
13247 if (data.quiet == 0) log_info ("");
13248
13249 /**
13250 * HM devices: copy
13251 */
13252
13253 if (gpu_temp_disable == 0)
13254 {
13255 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13256 {
13257 hc_device_param_t *device_param = &data.devices_param[device_id];
13258
13259 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13260
13261 if (device_param->skipped) continue;
13262
13263 const uint platform_devices_id = device_param->platform_devices_id;
13264
13265 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13266 if (device_param->vendor_id == VENDOR_ID_NV)
13267 {
13268 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13269 }
13270 #endif
13271
13272 #ifdef HAVE_ADL
13273 if (device_param->vendor_id == VENDOR_ID_AMD)
13274 {
13275 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13276 }
13277 #endif
13278 }
13279 }
13280
13281 /*
13282 * Temporary fix:
13283 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13284 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13285 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13286 * Driver / ADL bug?
13287 */
13288
13289 #ifdef HAVE_ADL
13290 if (powertune_enable == 1)
13291 {
13292 hc_thread_mutex_lock (mux_adl);
13293
13294 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13295 {
13296 hc_device_param_t *device_param = &data.devices_param[device_id];
13297
13298 if (device_param->skipped) continue;
13299
13300 if (data.hm_device[device_id].od_version == 6)
13301 {
13302 // set powertune value only
13303
13304 int powertune_supported = 0;
13305
13306 int ADL_rc = 0;
13307
13308 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13309 {
13310 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13311
13312 return (-1);
13313 }
13314
13315 if (powertune_supported != 0)
13316 {
13317 // powertune set
13318 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13319
13320 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13321 {
13322 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13323
13324 return (-1);
13325 }
13326
13327 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13328 {
13329 log_error ("ERROR: Failed to set new ADL PowerControl values");
13330
13331 return (-1);
13332 }
13333 }
13334 }
13335 }
13336
13337 hc_thread_mutex_unlock (mux_adl);
13338 }
13339 #endif // HAVE_ADK
13340 #endif // HAVE_HWMON
13341
13342 #ifdef DEBUG
13343 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13344 #endif
13345
13346 uint kernel_power_all = 0;
13347
13348 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13349 {
13350 /**
13351 * host buffer
13352 */
13353
13354 hc_device_param_t *device_param = &data.devices_param[device_id];
13355
13356 if (device_param->skipped) continue;
13357
13358 /**
13359 * device properties
13360 */
13361
13362 const char *device_name_chksum = device_param->device_name_chksum;
13363 const u32 device_processors = device_param->device_processors;
13364 const u32 device_processor_cores = device_param->device_processor_cores;
13365
13366 /**
13367 * create context for each device
13368 */
13369
13370 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13371
13372 /**
13373 * create command-queue
13374 */
13375
13376 // not supported with NV
13377 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13378
13379 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13380
13381 /**
13382 * create input buffers on device : calculate size of fixed memory buffers
13383 */
13384
13385 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13386 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13387
13388 device_param->size_root_css = size_root_css;
13389 device_param->size_markov_css = size_markov_css;
13390
13391 uint size_results = KERNEL_THREADS * sizeof (uint);
13392
13393 device_param->size_results = size_results;
13394
13395 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13396 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13397
13398 uint size_plains = digests_cnt * sizeof (plain_t);
13399 uint size_salts = salts_cnt * sizeof (salt_t);
13400 uint size_esalts = salts_cnt * esalt_size;
13401
13402 device_param->size_plains = size_plains;
13403 device_param->size_digests = size_digests;
13404 device_param->size_shown = size_shown;
13405 device_param->size_salts = size_salts;
13406
13407 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13408 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13409 uint size_tm = 32 * sizeof (bs_word_t);
13410
13411 // scryptV stuff
13412
13413 u64 size_scryptV = 1;
13414
13415 if ((hash_mode == 8900) || (hash_mode == 9300))
13416 {
13417 uint tmto_start = 0;
13418 uint tmto_stop = 10;
13419
13420 if (scrypt_tmto)
13421 {
13422 tmto_start = scrypt_tmto;
13423 }
13424 else
13425 {
13426 // in case the user did not specify the tmto manually
13427 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13428 // but set the lower end only in case the user has a device with too less memory
13429
13430 if (hash_mode == 8900)
13431 {
13432 if (device_param->vendor_id == VENDOR_ID_AMD)
13433 {
13434 tmto_start = 1;
13435 }
13436 else if (device_param->vendor_id == VENDOR_ID_NV)
13437 {
13438 tmto_start = 3;
13439 }
13440 }
13441 else if (hash_mode == 9300)
13442 {
13443 if (device_param->vendor_id == VENDOR_ID_AMD)
13444 {
13445 tmto_start = 3;
13446 }
13447 else if (device_param->vendor_id == VENDOR_ID_NV)
13448 {
13449 tmto_start = 5;
13450 }
13451 }
13452 }
13453
13454 if (quiet == 0) log_info ("");
13455
13456 uint shader_per_mp = 1;
13457
13458 if (device_param->vendor_id == VENDOR_ID_AMD)
13459 {
13460 shader_per_mp = 8;
13461 }
13462 else if (device_param->vendor_id == VENDOR_ID_NV)
13463 {
13464 shader_per_mp = 32;
13465 }
13466
13467 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13468 {
13469 // TODO: in theory the following calculation needs to be done per salt, not global
13470 // we assume all hashes have the same scrypt settings
13471
13472 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13473
13474 size_scryptV /= 1 << tmto;
13475
13476 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13477
13478 if (size_scryptV > device_param->device_maxmem_alloc)
13479 {
13480 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13481
13482 continue;
13483 }
13484
13485 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13486 {
13487 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13488 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13489 }
13490
13491 break;
13492 }
13493
13494 if (data.salts_buf[0].scrypt_phy == 0)
13495 {
13496 log_error ("ERROR: can't allocate enough device memory");
13497
13498 return -1;
13499 }
13500
13501 if (quiet == 0) log_info ("");
13502 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13503 }
13504
13505 /**
13506 * create input buffers on device : calculate size of dynamic size memory buffers
13507 */
13508
13509 uint kernel_threads = KERNEL_THREADS;
13510
13511 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13512
13513 if (hash_mode == 3200) kernel_threads = 8;
13514 if (hash_mode == 9000) kernel_threads = 8;
13515
13516 /**
13517 * some algorithms need a fixed kernel-loops count
13518 */
13519
13520 if (hash_mode == 1500)
13521 {
13522 const u32 kernel_loops_fixed = 1024;
13523
13524 device_param->kernel_loops_min = kernel_loops_fixed;
13525 device_param->kernel_loops_max = kernel_loops_fixed;
13526 }
13527
13528 if (hash_mode == 3000)
13529 {
13530 const u32 kernel_loops_fixed = 1024;
13531
13532 device_param->kernel_loops_min = kernel_loops_fixed;
13533 device_param->kernel_loops_max = kernel_loops_fixed;
13534 }
13535
13536 if (hash_mode == 8900)
13537 {
13538 const u32 kernel_loops_fixed = 1;
13539
13540 device_param->kernel_loops_min = kernel_loops_fixed;
13541 device_param->kernel_loops_max = kernel_loops_fixed;
13542 }
13543
13544 if (hash_mode == 9300)
13545 {
13546 const u32 kernel_loops_fixed = 1;
13547
13548 device_param->kernel_loops_min = kernel_loops_fixed;
13549 device_param->kernel_loops_max = kernel_loops_fixed;
13550 }
13551
13552 if (hash_mode == 12500)
13553 {
13554 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13555
13556 device_param->kernel_loops_min = kernel_loops_fixed;
13557 device_param->kernel_loops_max = kernel_loops_fixed;
13558 }
13559
13560 /**
13561 * some algorithms have a maximum kernel-loops count
13562 */
13563
13564 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13565 {
13566 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13567 {
13568 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13569 }
13570 }
13571
13572 /**
13573 * some algorithms need a special kernel-accel
13574 */
13575
13576 if (hash_mode == 8900)
13577 {
13578 device_param->kernel_accel_min = 1;
13579 device_param->kernel_accel_max = 64;
13580 }
13581
13582 if (hash_mode == 9300)
13583 {
13584 device_param->kernel_accel_min = 1;
13585 device_param->kernel_accel_max = 64;
13586 }
13587
13588 u32 kernel_accel_min = device_param->kernel_accel_min;
13589 u32 kernel_accel_max = device_param->kernel_accel_max;
13590
13591 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13592
13593 uint size_pws = 4;
13594 uint size_tmps = 4;
13595 uint size_hooks = 4;
13596
13597 while (kernel_accel_max >= kernel_accel_min)
13598 {
13599 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13600
13601 // size_pws
13602
13603 size_pws = kernel_power_max * sizeof (pw_t);
13604
13605 // size_tmps
13606
13607 switch (hash_mode)
13608 {
13609 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13610 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13611 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13612 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13613 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13614 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13615 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13616 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13617 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13618 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13619 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13620 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13621 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13622 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13623 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13624 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13625 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13626 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13627 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13628 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13629 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13630 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13631 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13632 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13633 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13634 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13635 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13636 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13637 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13638 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13639 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13640 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13641 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13642 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13643 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13644 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13645 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13646 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13647 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13648 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13649 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13650 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13651 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13652 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13653 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13654 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13655 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13656 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13657 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13658 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13659 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13660 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13661 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13662 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13663 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13664 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13665 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13666 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13667 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13668 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13669 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13670 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13671 };
13672
13673 // size_hooks
13674
13675 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13676 {
13677 // none yet
13678 }
13679
13680 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13681 // if not, decrease amplifier and try again
13682
13683 int skip = 0;
13684
13685 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13686 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13687 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13688
13689 if (( bitmap_size
13690 + bitmap_size
13691 + bitmap_size
13692 + bitmap_size
13693 + bitmap_size
13694 + bitmap_size
13695 + bitmap_size
13696 + bitmap_size
13697 + size_bfs
13698 + size_combs
13699 + size_digests
13700 + size_esalts
13701 + size_hooks
13702 + size_markov_css
13703 + size_plains
13704 + size_pws
13705 + size_results
13706 + size_root_css
13707 + size_rules
13708 + size_rules_c
13709 + size_salts
13710 + size_scryptV
13711 + size_shown
13712 + size_tm
13713 + size_tmps) > device_param->device_global_mem) skip = 1;
13714
13715 if (skip == 1)
13716 {
13717 kernel_accel_max--;
13718
13719 continue;
13720 }
13721
13722 break;
13723 }
13724
13725 /*
13726 if (kernel_accel_max == 0)
13727 {
13728 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13729
13730 return -1;
13731 }
13732 */
13733
13734 device_param->kernel_accel_min = kernel_accel_min;
13735 device_param->kernel_accel_max = kernel_accel_max;
13736
13737 /*
13738 if (kernel_accel_max < kernel_accel)
13739 {
13740 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13741
13742 device_param->kernel_accel = kernel_accel_max;
13743 }
13744 */
13745
13746 device_param->size_bfs = size_bfs;
13747 device_param->size_combs = size_combs;
13748 device_param->size_rules = size_rules;
13749 device_param->size_rules_c = size_rules_c;
13750 device_param->size_pws = size_pws;
13751 device_param->size_tmps = size_tmps;
13752 device_param->size_hooks = size_hooks;
13753
13754 // do not confuse kernel_accel_max with kernel_accel here
13755
13756 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13757
13758 device_param->kernel_threads = kernel_threads;
13759 device_param->kernel_power_user = kernel_power;
13760
13761 kernel_power_all += kernel_power;
13762
13763 /**
13764 * default building options
13765 */
13766
13767 char build_opts[1024] = { 0 };
13768
13769 // we don't have sm_* on vendors not NV but it doesn't matter
13770
13771 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);
13772
13773 /**
13774 * main kernel
13775 */
13776
13777 {
13778 /**
13779 * kernel source filename
13780 */
13781
13782 char source_file[256] = { 0 };
13783
13784 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13785
13786 struct stat sst;
13787
13788 if (stat (source_file, &sst) == -1)
13789 {
13790 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13791
13792 return -1;
13793 }
13794
13795 /**
13796 * kernel cached filename
13797 */
13798
13799 char cached_file[256] = { 0 };
13800
13801 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13802
13803 int cached = 1;
13804
13805 struct stat cst;
13806
13807 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13808 {
13809 cached = 0;
13810 }
13811
13812 /**
13813 * kernel compile or load
13814 */
13815
13816 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13817
13818 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13819
13820 if (force_jit_compilation == -1)
13821 {
13822 if (cached == 0)
13823 {
13824 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13825
13826 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13827
13828 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13829
13830 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13831
13832 if (rc != 0)
13833 {
13834 device_param->skipped = true;
13835 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13836 continue;
13837 }
13838
13839 size_t binary_size;
13840
13841 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13842
13843 u8 *binary = (u8 *) mymalloc (binary_size);
13844
13845 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13846
13847 writeProgramBin (cached_file, binary, binary_size);
13848
13849 local_free (binary);
13850 }
13851 else
13852 {
13853 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13854
13855 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13856
13857 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13858
13859 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13860 }
13861 }
13862 else
13863 {
13864 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13865
13866 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13867
13868 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13869
13870 char build_opts_update[1024] = { 0 };
13871
13872 if (force_jit_compilation == 1500)
13873 {
13874 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13875 }
13876 else if (force_jit_compilation == 8900)
13877 {
13878 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);
13879 }
13880 else
13881 {
13882 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
13883 }
13884
13885 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13886
13887 if (rc != 0)
13888 {
13889 device_param->skipped = true;
13890
13891 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13892 }
13893 }
13894
13895 local_free (kernel_lengths);
13896 local_free (kernel_sources[0]);
13897 local_free (kernel_sources);
13898 }
13899
13900 /**
13901 * word generator kernel
13902 */
13903
13904 if (attack_mode != ATTACK_MODE_STRAIGHT)
13905 {
13906 /**
13907 * kernel mp source filename
13908 */
13909
13910 char source_file[256] = { 0 };
13911
13912 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13913
13914 struct stat sst;
13915
13916 if (stat (source_file, &sst) == -1)
13917 {
13918 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13919
13920 return -1;
13921 }
13922
13923 /**
13924 * kernel mp cached filename
13925 */
13926
13927 char cached_file[256] = { 0 };
13928
13929 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13930
13931 int cached = 1;
13932
13933 struct stat cst;
13934
13935 if (stat (cached_file, &cst) == -1)
13936 {
13937 cached = 0;
13938 }
13939
13940 /**
13941 * kernel compile or load
13942 */
13943
13944 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13945
13946 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13947
13948 if (cached == 0)
13949 {
13950 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13951
13952 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13953
13954 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13955
13956 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
13957
13958 if (rc != 0)
13959 {
13960 device_param->skipped = true;
13961 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13962 continue;
13963 }
13964
13965 size_t binary_size;
13966
13967 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13968
13969 u8 *binary = (u8 *) mymalloc (binary_size);
13970
13971 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13972
13973 writeProgramBin (cached_file, binary, binary_size);
13974
13975 local_free (binary);
13976 }
13977 else
13978 {
13979 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13980
13981 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13982
13983 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13984
13985 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
13986 }
13987
13988 local_free (kernel_lengths);
13989 local_free (kernel_sources[0]);
13990 local_free (kernel_sources);
13991 }
13992
13993 /**
13994 * amplifier kernel
13995 */
13996
13997 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13998 {
13999
14000 }
14001 else
14002 {
14003 /**
14004 * kernel amp source filename
14005 */
14006
14007 char source_file[256] = { 0 };
14008
14009 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14010
14011 struct stat sst;
14012
14013 if (stat (source_file, &sst) == -1)
14014 {
14015 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14016
14017 return -1;
14018 }
14019
14020 /**
14021 * kernel amp cached filename
14022 */
14023
14024 char cached_file[256] = { 0 };
14025
14026 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14027
14028 int cached = 1;
14029
14030 struct stat cst;
14031
14032 if (stat (cached_file, &cst) == -1)
14033 {
14034 cached = 0;
14035 }
14036
14037 /**
14038 * kernel compile or load
14039 */
14040
14041 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14042
14043 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14044
14045 if (cached == 0)
14046 {
14047 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14048
14049 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14050
14051 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14052
14053 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14054
14055 if (rc != 0)
14056 {
14057 device_param->skipped = true;
14058 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14059 continue;
14060 }
14061
14062 size_t binary_size;
14063
14064 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14065
14066 u8 *binary = (u8 *) mymalloc (binary_size);
14067
14068 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14069
14070 writeProgramBin (cached_file, binary, binary_size);
14071
14072 local_free (binary);
14073 }
14074 else
14075 {
14076 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14077
14078 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14079
14080 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14081
14082 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14083 }
14084
14085 local_free (kernel_lengths);
14086 local_free (kernel_sources[0]);
14087 local_free (kernel_sources);
14088 }
14089
14090 // some algorithm collide too fast, make that impossible
14091
14092 if (benchmark == 1)
14093 {
14094 ((uint *) digests_buf)[0] = -1;
14095 ((uint *) digests_buf)[1] = -1;
14096 ((uint *) digests_buf)[2] = -1;
14097 ((uint *) digests_buf)[3] = -1;
14098 }
14099
14100 /**
14101 * global buffers
14102 */
14103
14104 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14105 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14106 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14107 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14108 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14109 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14110 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14111 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14112 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14113 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14114 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14115 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14116 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14117 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14118 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14119 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14120 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14121 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14122
14123 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);
14124 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);
14125 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);
14126 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);
14127 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);
14128 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);
14129 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);
14130 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);
14131 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14132 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14133 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14134
14135 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14136 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14137 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14138 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14139 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14140 run_kernel_bzero (device_param, device_param->d_result, size_results);
14141
14142 /**
14143 * special buffers
14144 */
14145
14146 if (attack_kern == ATTACK_KERN_STRAIGHT)
14147 {
14148 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14149 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14150
14151 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14152
14153 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14154 }
14155 else if (attack_kern == ATTACK_KERN_COMBI)
14156 {
14157 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14158 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14159 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14160 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14161
14162 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14163 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14164 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14165 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14166 }
14167 else if (attack_kern == ATTACK_KERN_BF)
14168 {
14169 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14170 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14171 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14172 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14173 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14174
14175 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14176 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14177 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14178 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14179 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14180 }
14181
14182 if (size_esalts)
14183 {
14184 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14185
14186 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14187 }
14188
14189 /**
14190 * main host data
14191 */
14192
14193 uint *result = (uint *) mymalloc (size_results);
14194
14195 device_param->result = result;
14196
14197 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14198
14199 device_param->pws_buf = pws_buf;
14200
14201 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14202
14203 device_param->combs_buf = combs_buf;
14204
14205 void *hooks_buf = mymalloc (size_hooks);
14206
14207 device_param->hooks_buf = hooks_buf;
14208
14209 /**
14210 * kernel args
14211 */
14212
14213 device_param->kernel_params_buf32[21] = bitmap_mask;
14214 device_param->kernel_params_buf32[22] = bitmap_shift1;
14215 device_param->kernel_params_buf32[23] = bitmap_shift2;
14216 device_param->kernel_params_buf32[24] = 0; // salt_pos
14217 device_param->kernel_params_buf32[25] = 0; // loop_pos
14218 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14219 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14220 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14221 device_param->kernel_params_buf32[29] = 0; // digests_offset
14222 device_param->kernel_params_buf32[30] = 0; // combs_mode
14223 device_param->kernel_params_buf32[31] = 0; // gid_max
14224
14225 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14226 ? &device_param->d_pws_buf
14227 : &device_param->d_pws_amp_buf;
14228 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14229 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14230 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14231 device_param->kernel_params[ 4] = &device_param->d_tmps;
14232 device_param->kernel_params[ 5] = &device_param->d_hooks;
14233 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14234 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14235 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14236 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14237 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14238 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14239 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14240 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14241 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14242 device_param->kernel_params[15] = &device_param->d_digests_buf;
14243 device_param->kernel_params[16] = &device_param->d_digests_shown;
14244 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14245 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14246 device_param->kernel_params[19] = &device_param->d_result;
14247 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14248 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14249 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14250 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14251 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14252 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14253 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14254 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14255 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14256 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14257 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14258 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14259
14260 device_param->kernel_params_mp_buf64[3] = 0;
14261 device_param->kernel_params_mp_buf32[4] = 0;
14262 device_param->kernel_params_mp_buf32[5] = 0;
14263 device_param->kernel_params_mp_buf32[6] = 0;
14264 device_param->kernel_params_mp_buf32[7] = 0;
14265 device_param->kernel_params_mp_buf32[8] = 0;
14266
14267 device_param->kernel_params_mp[0] = NULL;
14268 device_param->kernel_params_mp[1] = NULL;
14269 device_param->kernel_params_mp[2] = NULL;
14270 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14271 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14272 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14273 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14274 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14275 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14276
14277 device_param->kernel_params_mp_l_buf64[3] = 0;
14278 device_param->kernel_params_mp_l_buf32[4] = 0;
14279 device_param->kernel_params_mp_l_buf32[5] = 0;
14280 device_param->kernel_params_mp_l_buf32[6] = 0;
14281 device_param->kernel_params_mp_l_buf32[7] = 0;
14282 device_param->kernel_params_mp_l_buf32[8] = 0;
14283 device_param->kernel_params_mp_l_buf32[9] = 0;
14284
14285 device_param->kernel_params_mp_l[0] = NULL;
14286 device_param->kernel_params_mp_l[1] = NULL;
14287 device_param->kernel_params_mp_l[2] = NULL;
14288 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14289 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14290 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14291 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14292 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14293 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14294 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14295
14296 device_param->kernel_params_mp_r_buf64[3] = 0;
14297 device_param->kernel_params_mp_r_buf32[4] = 0;
14298 device_param->kernel_params_mp_r_buf32[5] = 0;
14299 device_param->kernel_params_mp_r_buf32[6] = 0;
14300 device_param->kernel_params_mp_r_buf32[7] = 0;
14301 device_param->kernel_params_mp_r_buf32[8] = 0;
14302
14303 device_param->kernel_params_mp_r[0] = NULL;
14304 device_param->kernel_params_mp_r[1] = NULL;
14305 device_param->kernel_params_mp_r[2] = NULL;
14306 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14307 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14308 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14309 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14310 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14311 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14312
14313 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14314 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14315
14316 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14317 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14318 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14319 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14320 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14321 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14322 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14323
14324 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14325
14326 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14327 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14328
14329 /**
14330 * kernel name
14331 */
14332
14333 char kernel_name[64] = { 0 };
14334
14335 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14336 {
14337 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14338 {
14339 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14340
14341 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14342
14343 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14344
14345 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14346
14347 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14348
14349 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14350 }
14351 else
14352 {
14353 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14354
14355 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14356
14357 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14358
14359 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14360
14361 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14362
14363 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14364 }
14365
14366 if (data.attack_mode == ATTACK_MODE_BF)
14367 {
14368 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14369 {
14370 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14371
14372 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14373
14374 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14375
14376 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14377 }
14378 }
14379 }
14380 else
14381 {
14382 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14383
14384 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14385
14386 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14387
14388 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14389
14390 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14391
14392 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14393
14394 if (opts_type & OPTS_TYPE_HOOK12)
14395 {
14396 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14397
14398 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14399 }
14400
14401 if (opts_type & OPTS_TYPE_HOOK23)
14402 {
14403 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14404
14405 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14406 }
14407 }
14408
14409 for (uint i = 0; i <= 20; i++)
14410 {
14411 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14412 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14413 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14414
14415 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14416 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14417 }
14418
14419 for (uint i = 21; i <= 31; i++)
14420 {
14421 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14422 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14423 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14424
14425 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14426 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14427 }
14428
14429 if (attack_mode == ATTACK_MODE_BF)
14430 {
14431 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14432 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14433
14434 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14435 {
14436 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14437
14438 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14439 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14440 }
14441 }
14442 else if (attack_mode == ATTACK_MODE_HYBRID1)
14443 {
14444 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14445 }
14446 else if (attack_mode == ATTACK_MODE_HYBRID2)
14447 {
14448 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14449 }
14450
14451 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14452 {
14453 // nothing to do
14454 }
14455 else
14456 {
14457 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14458 }
14459
14460 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14461 {
14462 // nothing to do
14463 }
14464 else
14465 {
14466 for (uint i = 0; i < 5; i++)
14467 {
14468 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14469 }
14470
14471 for (uint i = 5; i < 7; i++)
14472 {
14473 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14474 }
14475 }
14476
14477 /**
14478 * Store initial fanspeed if gpu_temp_retain is enabled
14479 */
14480
14481 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14482 int gpu_temp_retain_set = 0;
14483
14484 if (gpu_temp_disable == 0)
14485 {
14486 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14487 {
14488 hc_thread_mutex_lock (mux_adl);
14489
14490 if (data.hm_device[device_id].fan_supported == 1)
14491 {
14492 if (gpu_temp_retain_chgd == 0)
14493 {
14494 uint cur_temp = 0;
14495 uint default_temp = 0;
14496
14497 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);
14498
14499 if (ADL_rc == ADL_OK)
14500 {
14501 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14502
14503 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14504
14505 // special case with multi gpu setups: always use minimum retain
14506
14507 if (gpu_temp_retain_set == 0)
14508 {
14509 gpu_temp_retain = gpu_temp_retain_target;
14510 gpu_temp_retain_set = 1;
14511 }
14512 else
14513 {
14514 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14515 }
14516
14517 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14518 }
14519 }
14520
14521 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14522
14523 temp_retain_fanspeed_value[device_id] = fan_speed;
14524
14525 if (fan_speed == -1)
14526 {
14527 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14528
14529 temp_retain_fanspeed_value[device_id] = 0;
14530 }
14531 }
14532
14533 hc_thread_mutex_unlock (mux_adl);
14534 }
14535 }
14536
14537 /**
14538 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14539 */
14540
14541 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14542 {
14543 hc_thread_mutex_lock (mux_adl);
14544
14545 if (data.hm_device[device_id].od_version == 6)
14546 {
14547 int ADL_rc;
14548
14549 // check powertune capabilities first, if not available then skip device
14550
14551 int powertune_supported = 0;
14552
14553 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14554 {
14555 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14556
14557 return (-1);
14558 }
14559
14560 if (powertune_supported != 0)
14561 {
14562 // powercontrol settings
14563
14564 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14565
14566 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14567 {
14568 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14569 }
14570
14571 if (ADL_rc != ADL_OK)
14572 {
14573 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14574
14575 return (-1);
14576 }
14577
14578 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14579 {
14580 log_error ("ERROR: Failed to set new ADL PowerControl values");
14581
14582 return (-1);
14583 }
14584
14585 // clocks
14586
14587 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14588
14589 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14590
14591 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)
14592 {
14593 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14594
14595 return (-1);
14596 }
14597
14598 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14599
14600 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14601
14602 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14603 {
14604 log_error ("ERROR: Failed to get ADL device capabilities");
14605
14606 return (-1);
14607 }
14608
14609 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14610 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14611
14612 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14613 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14614
14615 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14616 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14617
14618 // warning if profile has too low max values
14619
14620 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14621 {
14622 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14623 }
14624
14625 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14626 {
14627 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14628 }
14629
14630 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14631
14632 performance_state->iNumberOfPerformanceLevels = 2;
14633
14634 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14635 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14636 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14637 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14638
14639 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)
14640 {
14641 log_info ("ERROR: Failed to set ADL performance state");
14642
14643 return (-1);
14644 }
14645
14646 local_free (performance_state);
14647 }
14648 }
14649
14650 hc_thread_mutex_unlock (mux_adl);
14651 }
14652 #endif // HAVE_HWMON && HAVE_ADL
14653 }
14654
14655 data.kernel_power_all = kernel_power_all;
14656
14657 if (data.quiet == 0) log_info ("");
14658
14659 /**
14660 * Inform user which algorithm is checked and at which workload setting
14661 */
14662
14663 if (benchmark == 1)
14664 {
14665 quiet = 0;
14666
14667 data.quiet = quiet;
14668
14669 char *hash_type = strhashtype (data.hash_mode); // not a bug
14670
14671 log_info ("Hashtype: %s", hash_type);
14672 log_info ("");
14673 }
14674
14675 /**
14676 * keep track of the progress
14677 */
14678
14679 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14680 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14681 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14682
14683 /**
14684 * open filehandles
14685 */
14686
14687 #if _WIN
14688 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14689 {
14690 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14691
14692 return (-1);
14693 }
14694
14695 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14696 {
14697 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14698
14699 return (-1);
14700 }
14701
14702 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14703 {
14704 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14705
14706 return (-1);
14707 }
14708 #endif
14709
14710 /**
14711 * dictionary pad
14712 */
14713
14714 segment_size *= (1024 * 1024);
14715
14716 data.segment_size = segment_size;
14717
14718 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14719
14720 wl_data->buf = (char *) mymalloc (segment_size);
14721 wl_data->avail = segment_size;
14722 wl_data->incr = segment_size;
14723 wl_data->cnt = 0;
14724 wl_data->pos = 0;
14725
14726 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14727
14728 data.wordlist_mode = wordlist_mode;
14729
14730 cs_t *css_buf = NULL;
14731 uint css_cnt = 0;
14732 uint dictcnt = 0;
14733 uint maskcnt = 1;
14734 char **masks = NULL;
14735 char **dictfiles = NULL;
14736
14737 uint mask_from_file = 0;
14738
14739 if (attack_mode == ATTACK_MODE_STRAIGHT)
14740 {
14741 if (wordlist_mode == WL_MODE_FILE)
14742 {
14743 int wls_left = myargc - (optind + 1);
14744
14745 for (int i = 0; i < wls_left; i++)
14746 {
14747 char *l0_filename = myargv[optind + 1 + i];
14748
14749 struct stat l0_stat;
14750
14751 if (stat (l0_filename, &l0_stat) == -1)
14752 {
14753 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14754
14755 return (-1);
14756 }
14757
14758 uint is_dir = S_ISDIR (l0_stat.st_mode);
14759
14760 if (is_dir == 0)
14761 {
14762 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14763
14764 dictcnt++;
14765
14766 dictfiles[dictcnt - 1] = l0_filename;
14767 }
14768 else
14769 {
14770 // do not allow --keyspace w/ a directory
14771
14772 if (keyspace == 1)
14773 {
14774 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14775
14776 return (-1);
14777 }
14778
14779 char **dictionary_files = NULL;
14780
14781 dictionary_files = scan_directory (l0_filename);
14782
14783 if (dictionary_files != NULL)
14784 {
14785 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14786
14787 for (int d = 0; dictionary_files[d] != NULL; d++)
14788 {
14789 char *l1_filename = dictionary_files[d];
14790
14791 struct stat l1_stat;
14792
14793 if (stat (l1_filename, &l1_stat) == -1)
14794 {
14795 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14796
14797 return (-1);
14798 }
14799
14800 if (S_ISREG (l1_stat.st_mode))
14801 {
14802 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14803
14804 dictcnt++;
14805
14806 dictfiles[dictcnt - 1] = strdup (l1_filename);
14807 }
14808 }
14809 }
14810
14811 local_free (dictionary_files);
14812 }
14813 }
14814
14815 if (dictcnt < 1)
14816 {
14817 log_error ("ERROR: No usable dictionary file found.");
14818
14819 return (-1);
14820 }
14821 }
14822 else if (wordlist_mode == WL_MODE_STDIN)
14823 {
14824 dictcnt = 1;
14825 }
14826 }
14827 else if (attack_mode == ATTACK_MODE_COMBI)
14828 {
14829 // display
14830
14831 char *dictfile1 = myargv[optind + 1 + 0];
14832 char *dictfile2 = myargv[optind + 1 + 1];
14833
14834 // find the bigger dictionary and use as base
14835
14836 FILE *fp1 = NULL;
14837 FILE *fp2 = NULL;
14838
14839 struct stat tmp_stat;
14840
14841 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14842 {
14843 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14844
14845 return (-1);
14846 }
14847
14848 if (stat (dictfile1, &tmp_stat) == -1)
14849 {
14850 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14851
14852 fclose (fp1);
14853
14854 return (-1);
14855 }
14856
14857 if (S_ISDIR (tmp_stat.st_mode))
14858 {
14859 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14860
14861 fclose (fp1);
14862
14863 return (-1);
14864 }
14865
14866 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14867 {
14868 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14869
14870 fclose (fp1);
14871
14872 return (-1);
14873 }
14874
14875 if (stat (dictfile2, &tmp_stat) == -1)
14876 {
14877 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14878
14879 fclose (fp1);
14880 fclose (fp2);
14881
14882 return (-1);
14883 }
14884
14885 if (S_ISDIR (tmp_stat.st_mode))
14886 {
14887 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14888
14889 fclose (fp1);
14890 fclose (fp2);
14891
14892 return (-1);
14893 }
14894
14895 data.combs_cnt = 1;
14896
14897 data.quiet = 1;
14898
14899 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14900
14901 data.quiet = quiet;
14902
14903 if (words1_cnt == 0)
14904 {
14905 log_error ("ERROR: %s: empty file", dictfile1);
14906
14907 fclose (fp1);
14908 fclose (fp2);
14909
14910 return (-1);
14911 }
14912
14913 data.combs_cnt = 1;
14914
14915 data.quiet = 1;
14916
14917 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14918
14919 data.quiet = quiet;
14920
14921 if (words2_cnt == 0)
14922 {
14923 log_error ("ERROR: %s: empty file", dictfile2);
14924
14925 fclose (fp1);
14926 fclose (fp2);
14927
14928 return (-1);
14929 }
14930
14931 fclose (fp1);
14932 fclose (fp2);
14933
14934 data.dictfile = dictfile1;
14935 data.dictfile2 = dictfile2;
14936
14937 if (words1_cnt >= words2_cnt)
14938 {
14939 data.combs_cnt = words2_cnt;
14940 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14941
14942 dictfiles = &data.dictfile;
14943
14944 dictcnt = 1;
14945 }
14946 else
14947 {
14948 data.combs_cnt = words1_cnt;
14949 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14950
14951 dictfiles = &data.dictfile2;
14952
14953 dictcnt = 1;
14954
14955 // we also have to switch wordlist related rules!
14956
14957 char *tmpc = data.rule_buf_l;
14958
14959 data.rule_buf_l = data.rule_buf_r;
14960 data.rule_buf_r = tmpc;
14961
14962 int tmpi = data.rule_len_l;
14963
14964 data.rule_len_l = data.rule_len_r;
14965 data.rule_len_r = tmpi;
14966 }
14967 }
14968 else if (attack_mode == ATTACK_MODE_BF)
14969 {
14970 char *mask = NULL;
14971
14972 maskcnt = 0;
14973
14974 if (benchmark == 0)
14975 {
14976 mask = myargv[optind + 1];
14977
14978 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14979
14980 if ((optind + 2) <= myargc)
14981 {
14982 struct stat file_stat;
14983
14984 if (stat (mask, &file_stat) == -1)
14985 {
14986 maskcnt = 1;
14987
14988 masks[maskcnt - 1] = mystrdup (mask);
14989 }
14990 else
14991 {
14992 int wls_left = myargc - (optind + 1);
14993
14994 uint masks_avail = INCR_MASKS;
14995
14996 for (int i = 0; i < wls_left; i++)
14997 {
14998 if (i != 0)
14999 {
15000 mask = myargv[optind + 1 + i];
15001
15002 if (stat (mask, &file_stat) == -1)
15003 {
15004 log_error ("ERROR: %s: %s", mask, strerror (errno));
15005
15006 return (-1);
15007 }
15008 }
15009
15010 uint is_file = S_ISREG (file_stat.st_mode);
15011
15012 if (is_file == 1)
15013 {
15014 FILE *mask_fp;
15015
15016 if ((mask_fp = fopen (mask, "r")) == NULL)
15017 {
15018 log_error ("ERROR: %s: %s", mask, strerror (errno));
15019
15020 return (-1);
15021 }
15022
15023 char line_buf[BUFSIZ] = { 0 };
15024
15025 while (!feof (mask_fp))
15026 {
15027 memset (line_buf, 0, BUFSIZ);
15028
15029 int line_len = fgetl (mask_fp, line_buf);
15030
15031 if (line_len == 0) continue;
15032
15033 if (line_buf[0] == '#') continue;
15034
15035 if (masks_avail == maskcnt)
15036 {
15037 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15038
15039 masks_avail += INCR_MASKS;
15040 }
15041
15042 masks[maskcnt] = mystrdup (line_buf);
15043
15044 maskcnt++;
15045 }
15046
15047 fclose (mask_fp);
15048 }
15049 else
15050 {
15051 log_error ("ERROR: %s: unsupported file-type", mask);
15052
15053 return (-1);
15054 }
15055 }
15056
15057 mask_from_file = 1;
15058 }
15059 }
15060 else
15061 {
15062 custom_charset_1 = (char *) "?l?d?u";
15063 custom_charset_2 = (char *) "?l?d";
15064 custom_charset_3 = (char *) "?l?d*!$@_";
15065
15066 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15067 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15068 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15069
15070 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15071
15072 wordlist_mode = WL_MODE_MASK;
15073
15074 data.wordlist_mode = wordlist_mode;
15075
15076 increment = 1;
15077
15078 maskcnt = 1;
15079 }
15080 }
15081 else
15082 {
15083 /**
15084 * generate full masks and charsets
15085 */
15086
15087 masks = (char **) mymalloc (sizeof (char *));
15088
15089 switch (hash_mode)
15090 {
15091 case 1731: pw_min = 5;
15092 pw_max = 5;
15093 mask = mystrdup ("?b?b?b?b?b");
15094 break;
15095 case 12500: pw_min = 5;
15096 pw_max = 5;
15097 mask = mystrdup ("?b?b?b?b?b");
15098 break;
15099 default: pw_min = 7;
15100 pw_max = 7;
15101 mask = mystrdup ("?b?b?b?b?b?b?b");
15102 break;
15103 }
15104
15105 maskcnt = 1;
15106
15107 masks[maskcnt - 1] = mystrdup (mask);
15108
15109 wordlist_mode = WL_MODE_MASK;
15110
15111 data.wordlist_mode = wordlist_mode;
15112
15113 increment = 1;
15114 }
15115
15116 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15117
15118 if (increment)
15119 {
15120 if (increment_min > pw_min) pw_min = increment_min;
15121
15122 if (increment_max < pw_max) pw_max = increment_max;
15123 }
15124 }
15125 else if (attack_mode == ATTACK_MODE_HYBRID1)
15126 {
15127 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15128
15129 // display
15130
15131 char *mask = myargv[myargc - 1];
15132
15133 maskcnt = 0;
15134
15135 masks = (char **) mymalloc (1 * sizeof (char *));
15136
15137 // mod
15138
15139 struct stat file_stat;
15140
15141 if (stat (mask, &file_stat) == -1)
15142 {
15143 maskcnt = 1;
15144
15145 masks[maskcnt - 1] = mystrdup (mask);
15146 }
15147 else
15148 {
15149 uint is_file = S_ISREG (file_stat.st_mode);
15150
15151 if (is_file == 1)
15152 {
15153 FILE *mask_fp;
15154
15155 if ((mask_fp = fopen (mask, "r")) == NULL)
15156 {
15157 log_error ("ERROR: %s: %s", mask, strerror (errno));
15158
15159 return (-1);
15160 }
15161
15162 char line_buf[BUFSIZ] = { 0 };
15163
15164 uint masks_avail = 1;
15165
15166 while (!feof (mask_fp))
15167 {
15168 memset (line_buf, 0, BUFSIZ);
15169
15170 int line_len = fgetl (mask_fp, line_buf);
15171
15172 if (line_len == 0) continue;
15173
15174 if (line_buf[0] == '#') continue;
15175
15176 if (masks_avail == maskcnt)
15177 {
15178 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15179
15180 masks_avail += INCR_MASKS;
15181 }
15182
15183 masks[maskcnt] = mystrdup (line_buf);
15184
15185 maskcnt++;
15186 }
15187
15188 fclose (mask_fp);
15189
15190 mask_from_file = 1;
15191 }
15192 else
15193 {
15194 maskcnt = 1;
15195
15196 masks[maskcnt - 1] = mystrdup (mask);
15197 }
15198 }
15199
15200 // base
15201
15202 int wls_left = myargc - (optind + 2);
15203
15204 for (int i = 0; i < wls_left; i++)
15205 {
15206 char *filename = myargv[optind + 1 + i];
15207
15208 struct stat file_stat;
15209
15210 if (stat (filename, &file_stat) == -1)
15211 {
15212 log_error ("ERROR: %s: %s", filename, strerror (errno));
15213
15214 return (-1);
15215 }
15216
15217 uint is_dir = S_ISDIR (file_stat.st_mode);
15218
15219 if (is_dir == 0)
15220 {
15221 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15222
15223 dictcnt++;
15224
15225 dictfiles[dictcnt - 1] = filename;
15226 }
15227 else
15228 {
15229 // do not allow --keyspace w/ a directory
15230
15231 if (keyspace == 1)
15232 {
15233 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15234
15235 return (-1);
15236 }
15237
15238 char **dictionary_files = NULL;
15239
15240 dictionary_files = scan_directory (filename);
15241
15242 if (dictionary_files != NULL)
15243 {
15244 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15245
15246 for (int d = 0; dictionary_files[d] != NULL; d++)
15247 {
15248 char *l1_filename = dictionary_files[d];
15249
15250 struct stat l1_stat;
15251
15252 if (stat (l1_filename, &l1_stat) == -1)
15253 {
15254 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15255
15256 return (-1);
15257 }
15258
15259 if (S_ISREG (l1_stat.st_mode))
15260 {
15261 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15262
15263 dictcnt++;
15264
15265 dictfiles[dictcnt - 1] = strdup (l1_filename);
15266 }
15267 }
15268 }
15269
15270 local_free (dictionary_files);
15271 }
15272 }
15273
15274 if (dictcnt < 1)
15275 {
15276 log_error ("ERROR: No usable dictionary file found.");
15277
15278 return (-1);
15279 }
15280
15281 if (increment)
15282 {
15283 maskcnt = 0;
15284
15285 uint mask_min = increment_min; // we can't reject smaller masks here
15286 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15287
15288 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15289 {
15290 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15291
15292 if (cur_mask == NULL) break;
15293
15294 masks[maskcnt] = cur_mask;
15295
15296 maskcnt++;
15297
15298 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15299 }
15300 }
15301 }
15302 else if (attack_mode == ATTACK_MODE_HYBRID2)
15303 {
15304 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15305
15306 // display
15307
15308 char *mask = myargv[optind + 1 + 0];
15309
15310 maskcnt = 0;
15311
15312 masks = (char **) mymalloc (1 * sizeof (char *));
15313
15314 // mod
15315
15316 struct stat file_stat;
15317
15318 if (stat (mask, &file_stat) == -1)
15319 {
15320 maskcnt = 1;
15321
15322 masks[maskcnt - 1] = mystrdup (mask);
15323 }
15324 else
15325 {
15326 uint is_file = S_ISREG (file_stat.st_mode);
15327
15328 if (is_file == 1)
15329 {
15330 FILE *mask_fp;
15331
15332 if ((mask_fp = fopen (mask, "r")) == NULL)
15333 {
15334 log_error ("ERROR: %s: %s", mask, strerror (errno));
15335
15336 return (-1);
15337 }
15338
15339 char line_buf[BUFSIZ] = { 0 };
15340
15341 uint masks_avail = 1;
15342
15343 while (!feof (mask_fp))
15344 {
15345 memset (line_buf, 0, BUFSIZ);
15346
15347 int line_len = fgetl (mask_fp, line_buf);
15348
15349 if (line_len == 0) continue;
15350
15351 if (line_buf[0] == '#') continue;
15352
15353 if (masks_avail == maskcnt)
15354 {
15355 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15356
15357 masks_avail += INCR_MASKS;
15358 }
15359
15360 masks[maskcnt] = mystrdup (line_buf);
15361
15362 maskcnt++;
15363 }
15364
15365 fclose (mask_fp);
15366
15367 mask_from_file = 1;
15368 }
15369 else
15370 {
15371 maskcnt = 1;
15372
15373 masks[maskcnt - 1] = mystrdup (mask);
15374 }
15375 }
15376
15377 // base
15378
15379 int wls_left = myargc - (optind + 2);
15380
15381 for (int i = 0; i < wls_left; i++)
15382 {
15383 char *filename = myargv[optind + 2 + i];
15384
15385 struct stat file_stat;
15386
15387 if (stat (filename, &file_stat) == -1)
15388 {
15389 log_error ("ERROR: %s: %s", filename, strerror (errno));
15390
15391 return (-1);
15392 }
15393
15394 uint is_dir = S_ISDIR (file_stat.st_mode);
15395
15396 if (is_dir == 0)
15397 {
15398 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15399
15400 dictcnt++;
15401
15402 dictfiles[dictcnt - 1] = filename;
15403 }
15404 else
15405 {
15406 // do not allow --keyspace w/ a directory
15407
15408 if (keyspace == 1)
15409 {
15410 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15411
15412 return (-1);
15413 }
15414
15415 char **dictionary_files = NULL;
15416
15417 dictionary_files = scan_directory (filename);
15418
15419 if (dictionary_files != NULL)
15420 {
15421 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15422
15423 for (int d = 0; dictionary_files[d] != NULL; d++)
15424 {
15425 char *l1_filename = dictionary_files[d];
15426
15427 struct stat l1_stat;
15428
15429 if (stat (l1_filename, &l1_stat) == -1)
15430 {
15431 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15432
15433 return (-1);
15434 }
15435
15436 if (S_ISREG (l1_stat.st_mode))
15437 {
15438 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15439
15440 dictcnt++;
15441
15442 dictfiles[dictcnt - 1] = strdup (l1_filename);
15443 }
15444 }
15445 }
15446
15447 local_free (dictionary_files);
15448 }
15449 }
15450
15451 if (dictcnt < 1)
15452 {
15453 log_error ("ERROR: No usable dictionary file found.");
15454
15455 return (-1);
15456 }
15457
15458 if (increment)
15459 {
15460 maskcnt = 0;
15461
15462 uint mask_min = increment_min; // we can't reject smaller masks here
15463 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15464
15465 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15466 {
15467 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15468
15469 if (cur_mask == NULL) break;
15470
15471 masks[maskcnt] = cur_mask;
15472
15473 maskcnt++;
15474
15475 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15476 }
15477 }
15478 }
15479
15480 data.pw_min = pw_min;
15481 data.pw_max = pw_max;
15482
15483 /**
15484 * weak hash check
15485 */
15486
15487 if (weak_hash_threshold >= salts_cnt)
15488 {
15489 hc_device_param_t *device_param = NULL;
15490
15491 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15492 {
15493 device_param = &data.devices_param[device_id];
15494
15495 if (device_param->skipped) continue;
15496
15497 break;
15498 }
15499
15500 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15501
15502 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15503 {
15504 weak_hash_check (device_param, salt_pos);
15505 }
15506 }
15507
15508 // Display hack, guarantee that there is at least one \r before real start
15509
15510 if (data.quiet == 0) log_info_nn ("");
15511
15512 /**
15513 * status and monitor threads
15514 */
15515
15516 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15517
15518 hc_thread_t i_thread = 0;
15519
15520 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15521 {
15522 hc_thread_create (i_thread, thread_keypress, &benchmark);
15523 }
15524
15525 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15526
15527 uint ni_threads_cnt = 0;
15528
15529 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15530
15531 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15532
15533 ni_threads_cnt++;
15534
15535 /**
15536 * Outfile remove
15537 */
15538
15539 if (keyspace == 0)
15540 {
15541 if (outfile_check_timer != 0)
15542 {
15543 if (data.outfile_check_directory != NULL)
15544 {
15545 if ((hash_mode != 5200) &&
15546 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15547 (hash_mode != 9000))
15548 {
15549 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15550
15551 ni_threads_cnt++;
15552 }
15553 else
15554 {
15555 outfile_check_timer = 0;
15556 }
15557 }
15558 else
15559 {
15560 outfile_check_timer = 0;
15561 }
15562 }
15563 }
15564
15565 /**
15566 * Inform the user if we got some hashes remove because of the pot file remove feature
15567 */
15568
15569 if (data.quiet == 0)
15570 {
15571 if (potfile_remove_cracks > 0)
15572 {
15573 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15574 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15575 }
15576 }
15577
15578 data.outfile_check_timer = outfile_check_timer;
15579
15580 /**
15581 * main loop
15582 */
15583
15584 char **induction_dictionaries = NULL;
15585
15586 int induction_dictionaries_cnt = 0;
15587
15588 hcstat_table_t *root_table_buf = NULL;
15589 hcstat_table_t *markov_table_buf = NULL;
15590
15591 uint initial_restore_done = 0;
15592
15593 data.maskcnt = maskcnt;
15594
15595 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15596 {
15597 if (data.devices_status == STATUS_CRACKED) break;
15598
15599 data.devices_status = STATUS_INIT;
15600
15601 if (maskpos > rd->maskpos)
15602 {
15603 rd->dictpos = 0;
15604 }
15605
15606 rd->maskpos = maskpos;
15607 data.maskpos = maskpos;
15608
15609 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15610 {
15611 char *mask = masks[maskpos];
15612
15613 if (mask_from_file == 1)
15614 {
15615 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15616
15617 char *str_ptr;
15618 uint str_pos;
15619
15620 uint mask_offset = 0;
15621
15622 uint separator_cnt;
15623
15624 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15625 {
15626 str_ptr = strstr (mask + mask_offset, ",");
15627
15628 if (str_ptr == NULL) break;
15629
15630 str_pos = str_ptr - mask;
15631
15632 // escaped separator, i.e. "\,"
15633
15634 if (str_pos > 0)
15635 {
15636 if (mask[str_pos - 1] == '\\')
15637 {
15638 separator_cnt --;
15639
15640 mask_offset = str_pos + 1;
15641
15642 continue;
15643 }
15644 }
15645
15646 // reset the offset
15647
15648 mask_offset = 0;
15649
15650 mask[str_pos] = '\0';
15651
15652 switch (separator_cnt)
15653 {
15654 case 0:
15655 mp_reset_usr (mp_usr, 0);
15656
15657 custom_charset_1 = mask;
15658 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15659 break;
15660
15661 case 1:
15662 mp_reset_usr (mp_usr, 1);
15663
15664 custom_charset_2 = mask;
15665 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15666 break;
15667
15668 case 2:
15669 mp_reset_usr (mp_usr, 2);
15670
15671 custom_charset_3 = mask;
15672 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15673 break;
15674
15675 case 3:
15676 mp_reset_usr (mp_usr, 3);
15677
15678 custom_charset_4 = mask;
15679 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15680 break;
15681 }
15682
15683 mask = mask + str_pos + 1;
15684 }
15685 }
15686
15687 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15688 {
15689 if (maskpos > 0)
15690 {
15691 local_free (css_buf);
15692 local_free (data.root_css_buf);
15693 local_free (data.markov_css_buf);
15694
15695 local_free (masks[maskpos - 1]);
15696 }
15697
15698 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15699
15700 data.mask = mask;
15701 data.css_cnt = css_cnt;
15702 data.css_buf = css_buf;
15703
15704 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15705
15706 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15707
15708 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15709 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15710
15711 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15712
15713 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15714
15715 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15716 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15717
15718 data.root_css_buf = root_css_buf;
15719 data.markov_css_buf = markov_css_buf;
15720
15721 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15722
15723 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15724
15725 local_free (root_table_buf);
15726 local_free (markov_table_buf);
15727
15728 // args
15729
15730 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15731 {
15732 hc_device_param_t *device_param = &data.devices_param[device_id];
15733
15734 if (device_param->skipped) continue;
15735
15736 device_param->kernel_params_mp[0] = &device_param->d_combs;
15737 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15738 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15739
15740 device_param->kernel_params_mp_buf64[3] = 0;
15741 device_param->kernel_params_mp_buf32[4] = css_cnt;
15742 device_param->kernel_params_mp_buf32[5] = 0;
15743 device_param->kernel_params_mp_buf32[6] = 0;
15744 device_param->kernel_params_mp_buf32[7] = 0;
15745
15746 if (attack_mode == ATTACK_MODE_HYBRID1)
15747 {
15748 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15749 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15750 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15751 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15752 }
15753 else if (attack_mode == ATTACK_MODE_HYBRID2)
15754 {
15755 device_param->kernel_params_mp_buf32[5] = 0;
15756 device_param->kernel_params_mp_buf32[6] = 0;
15757 device_param->kernel_params_mp_buf32[7] = 0;
15758 }
15759
15760 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]);
15761 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]);
15762 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]);
15763
15764 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);
15765 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);
15766 }
15767 }
15768 else if (attack_mode == ATTACK_MODE_BF)
15769 {
15770 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15771
15772 if (increment)
15773 {
15774 for (uint i = 0; i < dictcnt; i++)
15775 {
15776 local_free (dictfiles[i]);
15777 }
15778
15779 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15780 {
15781 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15782
15783 if (l1_filename == NULL) break;
15784
15785 dictcnt++;
15786
15787 dictfiles[dictcnt - 1] = l1_filename;
15788 }
15789 }
15790 else
15791 {
15792 dictcnt++;
15793
15794 dictfiles[dictcnt - 1] = mask;
15795 }
15796
15797 if (dictcnt == 0)
15798 {
15799 log_error ("ERROR: Mask is too small");
15800
15801 return (-1);
15802 }
15803 }
15804 }
15805
15806 free (induction_dictionaries);
15807
15808 // induction_dictionaries_cnt = 0; // implied
15809
15810 if (attack_mode != ATTACK_MODE_BF)
15811 {
15812 if (keyspace == 0)
15813 {
15814 induction_dictionaries = scan_directory (induction_directory);
15815
15816 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15817 }
15818 }
15819
15820 if (induction_dictionaries_cnt)
15821 {
15822 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15823 }
15824
15825 /**
15826 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15827 */
15828 if (keyspace == 1)
15829 {
15830 if ((maskcnt > 1) || (dictcnt > 1))
15831 {
15832 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15833
15834 return (-1);
15835 }
15836 }
15837
15838 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15839 {
15840 char *subid = logfile_generate_subid ();
15841
15842 data.subid = subid;
15843
15844 logfile_sub_msg ("START");
15845
15846 data.devices_status = STATUS_INIT;
15847
15848 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15849 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15850 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15851
15852 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15853
15854 data.cpt_pos = 0;
15855
15856 data.cpt_start = time (NULL);
15857
15858 data.cpt_total = 0;
15859
15860 if (data.restore == 0)
15861 {
15862 rd->words_cur = skip;
15863
15864 skip = 0;
15865
15866 data.skip = 0;
15867 }
15868
15869 data.ms_paused = 0;
15870
15871 data.words_cur = rd->words_cur;
15872
15873 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15874 {
15875 hc_device_param_t *device_param = &data.devices_param[device_id];
15876
15877 if (device_param->skipped) continue;
15878
15879 device_param->speed_pos = 0;
15880
15881 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15882 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15883 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15884
15885 device_param->exec_pos = 0;
15886
15887 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15888
15889 device_param->kernel_power = device_param->kernel_power_user;
15890
15891 device_param->outerloop_pos = 0;
15892 device_param->outerloop_left = 0;
15893 device_param->innerloop_pos = 0;
15894 device_param->innerloop_left = 0;
15895
15896 // some more resets:
15897
15898 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15899
15900 device_param->pws_cnt = 0;
15901
15902 device_param->words_off = 0;
15903 device_param->words_done = 0;
15904 }
15905
15906 data.kernel_power_div = 0;
15907
15908 // figure out some workload
15909
15910 if (attack_mode == ATTACK_MODE_STRAIGHT)
15911 {
15912 if (data.wordlist_mode == WL_MODE_FILE)
15913 {
15914 char *dictfile = NULL;
15915
15916 if (induction_dictionaries_cnt)
15917 {
15918 dictfile = induction_dictionaries[0];
15919 }
15920 else
15921 {
15922 dictfile = dictfiles[dictpos];
15923 }
15924
15925 data.dictfile = dictfile;
15926
15927 logfile_sub_string (dictfile);
15928
15929 for (uint i = 0; i < rp_files_cnt; i++)
15930 {
15931 logfile_sub_var_string ("rulefile", rp_files[i]);
15932 }
15933
15934 FILE *fd2 = fopen (dictfile, "rb");
15935
15936 if (fd2 == NULL)
15937 {
15938 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15939
15940 return (-1);
15941 }
15942
15943 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15944
15945 fclose (fd2);
15946
15947 if (data.words_cnt == 0)
15948 {
15949 if (data.devices_status == STATUS_CRACKED) break;
15950 if (data.devices_status == STATUS_ABORTED) break;
15951
15952 dictpos++;
15953
15954 continue;
15955 }
15956 }
15957 }
15958 else if (attack_mode == ATTACK_MODE_COMBI)
15959 {
15960 char *dictfile = data.dictfile;
15961 char *dictfile2 = data.dictfile2;
15962
15963 logfile_sub_string (dictfile);
15964 logfile_sub_string (dictfile2);
15965
15966 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15967 {
15968 FILE *fd2 = fopen (dictfile, "rb");
15969
15970 if (fd2 == NULL)
15971 {
15972 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15973
15974 return (-1);
15975 }
15976
15977 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15978
15979 fclose (fd2);
15980 }
15981 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15982 {
15983 FILE *fd2 = fopen (dictfile2, "rb");
15984
15985 if (fd2 == NULL)
15986 {
15987 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15988
15989 return (-1);
15990 }
15991
15992 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15993
15994 fclose (fd2);
15995 }
15996
15997 if (data.words_cnt == 0)
15998 {
15999 if (data.devices_status == STATUS_CRACKED) break;
16000 if (data.devices_status == STATUS_ABORTED) break;
16001
16002 dictpos++;
16003
16004 continue;
16005 }
16006 }
16007 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16008 {
16009 char *dictfile = NULL;
16010
16011 if (induction_dictionaries_cnt)
16012 {
16013 dictfile = induction_dictionaries[0];
16014 }
16015 else
16016 {
16017 dictfile = dictfiles[dictpos];
16018 }
16019
16020 data.dictfile = dictfile;
16021
16022 char *mask = data.mask;
16023
16024 logfile_sub_string (dictfile);
16025 logfile_sub_string (mask);
16026
16027 FILE *fd2 = fopen (dictfile, "rb");
16028
16029 if (fd2 == NULL)
16030 {
16031 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16032
16033 return (-1);
16034 }
16035
16036 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16037
16038 fclose (fd2);
16039
16040 if (data.words_cnt == 0)
16041 {
16042 if (data.devices_status == STATUS_CRACKED) break;
16043 if (data.devices_status == STATUS_ABORTED) break;
16044
16045 dictpos++;
16046
16047 continue;
16048 }
16049 }
16050 else if (attack_mode == ATTACK_MODE_BF)
16051 {
16052 local_free (css_buf);
16053 local_free (data.root_css_buf);
16054 local_free (data.markov_css_buf);
16055
16056 char *mask = dictfiles[dictpos];
16057
16058 logfile_sub_string (mask);
16059
16060 // base
16061
16062 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16063
16064 if (opts_type & OPTS_TYPE_PT_UNICODE)
16065 {
16066 uint css_cnt_unicode = css_cnt * 2;
16067
16068 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16069
16070 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16071 {
16072 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16073
16074 css_buf_unicode[j + 1].cs_buf[0] = 0;
16075 css_buf_unicode[j + 1].cs_len = 1;
16076 }
16077
16078 free (css_buf);
16079
16080 css_buf = css_buf_unicode;
16081 css_cnt = css_cnt_unicode;
16082 }
16083
16084 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16085
16086 uint mask_min = pw_min;
16087 uint mask_max = pw_max;
16088
16089 if (opts_type & OPTS_TYPE_PT_UNICODE)
16090 {
16091 mask_min *= 2;
16092 mask_max *= 2;
16093 }
16094
16095 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16096 {
16097 if (css_cnt < mask_min)
16098 {
16099 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16100 }
16101
16102 if (css_cnt > mask_max)
16103 {
16104 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16105 }
16106
16107 // skip to next mask
16108
16109 dictpos++;
16110
16111 rd->dictpos = dictpos;
16112
16113 logfile_sub_msg ("STOP");
16114
16115 continue;
16116 }
16117
16118 uint save_css_cnt = css_cnt;
16119
16120 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16121 {
16122 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16123 {
16124 uint salt_len = (uint) data.salts_buf[0].salt_len;
16125 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16126
16127 uint css_cnt_salt = css_cnt + salt_len;
16128
16129 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16130
16131 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16132
16133 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16134 {
16135 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16136 css_buf_salt[j].cs_len = 1;
16137 }
16138
16139 free (css_buf);
16140
16141 css_buf = css_buf_salt;
16142 css_cnt = css_cnt_salt;
16143 }
16144 }
16145
16146 data.mask = mask;
16147 data.css_cnt = css_cnt;
16148 data.css_buf = css_buf;
16149
16150 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16151
16152 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16153
16154 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16155
16156 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16157 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16158
16159 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16160
16161 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16162
16163 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16164 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16165
16166 data.root_css_buf = root_css_buf;
16167 data.markov_css_buf = markov_css_buf;
16168
16169 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16170
16171 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16172
16173 local_free (root_table_buf);
16174 local_free (markov_table_buf);
16175
16176 // copy + args
16177
16178 uint css_cnt_l = css_cnt;
16179 uint css_cnt_r;
16180
16181 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16182 {
16183 if (save_css_cnt < 6)
16184 {
16185 css_cnt_r = 1;
16186 }
16187 else if (save_css_cnt == 6)
16188 {
16189 css_cnt_r = 2;
16190 }
16191 else
16192 {
16193 if (opts_type & OPTS_TYPE_PT_UNICODE)
16194 {
16195 if (save_css_cnt == 8 || save_css_cnt == 10)
16196 {
16197 css_cnt_r = 2;
16198 }
16199 else
16200 {
16201 css_cnt_r = 4;
16202 }
16203 }
16204 else
16205 {
16206 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16207 {
16208 css_cnt_r = 3;
16209 }
16210 else
16211 {
16212 css_cnt_r = 4;
16213 }
16214 }
16215 }
16216 }
16217 else
16218 {
16219 css_cnt_r = 1;
16220
16221 /* unfinished code?
16222 int sum = css_buf[css_cnt_r - 1].cs_len;
16223
16224 for (uint i = 1; i < 4 && i < css_cnt; i++)
16225 {
16226 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16227
16228 css_cnt_r++;
16229
16230 sum *= css_buf[css_cnt_r - 1].cs_len;
16231 }
16232 */
16233 }
16234
16235 css_cnt_l -= css_cnt_r;
16236
16237 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16238
16239 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16240 {
16241 hc_device_param_t *device_param = &data.devices_param[device_id];
16242
16243 if (device_param->skipped) continue;
16244
16245 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16246 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16247 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16248
16249 device_param->kernel_params_mp_l_buf64[3] = 0;
16250 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16251 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16252 device_param->kernel_params_mp_l_buf32[6] = 0;
16253 device_param->kernel_params_mp_l_buf32[7] = 0;
16254 device_param->kernel_params_mp_l_buf32[8] = 0;
16255
16256 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16257 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16258 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16259 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16260
16261 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16262 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16263 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16264
16265 device_param->kernel_params_mp_r_buf64[3] = 0;
16266 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16267 device_param->kernel_params_mp_r_buf32[5] = 0;
16268 device_param->kernel_params_mp_r_buf32[6] = 0;
16269 device_param->kernel_params_mp_r_buf32[7] = 0;
16270
16271 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]);
16272 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]);
16273 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]);
16274
16275 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]);
16276 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]);
16277 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]);
16278
16279 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);
16280 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);
16281 }
16282 }
16283
16284 u64 words_base = data.words_cnt;
16285
16286 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16287 {
16288 if (data.kernel_rules_cnt)
16289 {
16290 words_base /= data.kernel_rules_cnt;
16291 }
16292 }
16293 else if (data.attack_kern == ATTACK_KERN_COMBI)
16294 {
16295 if (data.combs_cnt)
16296 {
16297 words_base /= data.combs_cnt;
16298 }
16299 }
16300 else if (data.attack_kern == ATTACK_KERN_BF)
16301 {
16302 if (data.bfs_cnt)
16303 {
16304 words_base /= data.bfs_cnt;
16305 }
16306 }
16307
16308 data.words_base = words_base;
16309
16310 if (keyspace == 1)
16311 {
16312 log_info ("%llu", (unsigned long long int) words_base);
16313
16314 return (0);
16315 }
16316
16317 if (data.words_cur > data.words_base)
16318 {
16319 log_error ("ERROR: restore value greater keyspace");
16320
16321 return (-1);
16322 }
16323
16324 if (data.words_cur)
16325 {
16326 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16327 {
16328 for (uint i = 0; i < data.salts_cnt; i++)
16329 {
16330 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16331 }
16332 }
16333 else if (data.attack_kern == ATTACK_KERN_COMBI)
16334 {
16335 for (uint i = 0; i < data.salts_cnt; i++)
16336 {
16337 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16338 }
16339 }
16340 else if (data.attack_kern == ATTACK_KERN_BF)
16341 {
16342 for (uint i = 0; i < data.salts_cnt; i++)
16343 {
16344 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16345 }
16346 }
16347 }
16348
16349 /*
16350 * Inform user about possible slow speeds
16351 */
16352
16353 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16354 {
16355 if (data.words_base < kernel_power_all)
16356 {
16357 if (quiet == 0)
16358 {
16359 log_info ("");
16360 log_info ("ATTENTION!");
16361 log_info (" The wordlist or mask you are using is too small.");
16362 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16363 log_info (" The cracking speed will drop.");
16364 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16365 log_info ("");
16366 }
16367 }
16368 }
16369
16370 /*
16371 * Update loopback file
16372 */
16373
16374 if (loopback == 1)
16375 {
16376 time_t now;
16377
16378 time (&now);
16379
16380 uint random_num = get_random_num (0, 9999);
16381
16382 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16383
16384 data.loopback_file = loopback_file;
16385 }
16386
16387 /*
16388 * Update dictionary statistic
16389 */
16390
16391 if (keyspace == 0)
16392 {
16393 dictstat_fp = fopen (dictstat, "wb");
16394
16395 if (dictstat_fp)
16396 {
16397 lock_file (dictstat_fp);
16398
16399 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16400
16401 fclose (dictstat_fp);
16402 }
16403 }
16404
16405 data.devices_status = STATUS_RUNNING;
16406
16407 if (initial_restore_done == 0)
16408 {
16409 if (data.restore_disable == 0) cycle_restore ();
16410
16411 initial_restore_done = 1;
16412 }
16413
16414 hc_timer_set (&data.timer_running);
16415
16416 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16417 {
16418 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16419 {
16420 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16421 if (quiet == 0) fflush (stdout);
16422 }
16423 }
16424 else if (wordlist_mode == WL_MODE_STDIN)
16425 {
16426 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16427 if (data.quiet == 0) log_info ("");
16428 }
16429
16430 time_t runtime_start;
16431
16432 time (&runtime_start);
16433
16434 data.runtime_start = runtime_start;
16435
16436 /**
16437 * create cracker threads
16438 */
16439
16440 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16441
16442 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16443 {
16444 hc_device_param_t *device_param = &devices_param[device_id];
16445
16446 if (wordlist_mode == WL_MODE_STDIN)
16447 {
16448 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16449 }
16450 else
16451 {
16452 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16453 }
16454 }
16455
16456 // wait for crack threads to exit
16457
16458 hc_thread_wait (data.devices_cnt, c_threads);
16459
16460 local_free (c_threads);
16461
16462 data.restore = 0;
16463
16464 // finalize task
16465
16466 logfile_sub_var_uint ("status-after-work", data.devices_status);
16467
16468 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16469
16470 if (data.devices_status == STATUS_CRACKED) break;
16471 if (data.devices_status == STATUS_ABORTED) break;
16472
16473 if (data.devices_status == STATUS_BYPASS)
16474 {
16475 data.devices_status = STATUS_RUNNING;
16476 }
16477
16478 if (induction_dictionaries_cnt)
16479 {
16480 unlink (induction_dictionaries[0]);
16481 }
16482
16483 free (induction_dictionaries);
16484
16485 if (attack_mode != ATTACK_MODE_BF)
16486 {
16487 induction_dictionaries = scan_directory (induction_directory);
16488
16489 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16490 }
16491
16492 if (benchmark == 0)
16493 {
16494 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16495 {
16496 if (quiet == 0) clear_prompt ();
16497
16498 if (quiet == 0) log_info ("");
16499
16500 if (status == 1)
16501 {
16502 status_display ();
16503 }
16504 else
16505 {
16506 if (quiet == 0) status_display ();
16507 }
16508
16509 if (quiet == 0) log_info ("");
16510 }
16511 }
16512
16513 if (attack_mode == ATTACK_MODE_BF)
16514 {
16515 dictpos++;
16516
16517 rd->dictpos = dictpos;
16518 }
16519 else
16520 {
16521 if (induction_dictionaries_cnt)
16522 {
16523 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16524 }
16525 else
16526 {
16527 dictpos++;
16528
16529 rd->dictpos = dictpos;
16530 }
16531 }
16532
16533 time_t runtime_stop;
16534
16535 time (&runtime_stop);
16536
16537 data.runtime_stop = runtime_stop;
16538
16539 logfile_sub_uint (runtime_start);
16540 logfile_sub_uint (runtime_stop);
16541
16542 logfile_sub_msg ("STOP");
16543
16544 global_free (subid);
16545 }
16546
16547 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16548
16549 if (data.devices_status == STATUS_CRACKED) break;
16550 if (data.devices_status == STATUS_ABORTED) break;
16551 if (data.devices_status == STATUS_QUIT) break;
16552
16553 if (data.devices_status == STATUS_BYPASS)
16554 {
16555 data.devices_status = STATUS_RUNNING;
16556 }
16557 }
16558
16559 // 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
16560
16561 if (attack_mode == ATTACK_MODE_STRAIGHT)
16562 {
16563 if (data.wordlist_mode == WL_MODE_FILE)
16564 {
16565 if (data.dictfile == NULL)
16566 {
16567 if (dictfiles != NULL)
16568 {
16569 data.dictfile = dictfiles[0];
16570
16571 hc_timer_set (&data.timer_running);
16572 }
16573 }
16574 }
16575 }
16576 // NOTE: combi is okay because it is already set beforehand
16577 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16578 {
16579 if (data.dictfile == NULL)
16580 {
16581 if (dictfiles != NULL)
16582 {
16583 hc_timer_set (&data.timer_running);
16584
16585 data.dictfile = dictfiles[0];
16586 }
16587 }
16588 }
16589 else if (attack_mode == ATTACK_MODE_BF)
16590 {
16591 if (data.mask == NULL)
16592 {
16593 hc_timer_set (&data.timer_running);
16594
16595 data.mask = masks[0];
16596 }
16597 }
16598
16599 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16600 {
16601 data.devices_status = STATUS_EXHAUSTED;
16602 }
16603
16604 // if cracked / aborted remove last induction dictionary
16605
16606 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16607 {
16608 struct stat induct_stat;
16609
16610 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16611 {
16612 unlink (induction_dictionaries[file_pos]);
16613 }
16614 }
16615
16616 // wait for non-interactive threads
16617
16618 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16619 {
16620 hc_thread_wait (1, &ni_threads[thread_idx]);
16621 }
16622
16623 local_free (ni_threads);
16624
16625 // wait for interactive threads
16626
16627 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16628 {
16629 hc_thread_wait (1, &i_thread);
16630 }
16631
16632 // we dont need restore file anymore
16633 if (data.restore_disable == 0)
16634 {
16635 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16636 {
16637 unlink (eff_restore_file);
16638 unlink (new_restore_file);
16639 }
16640 else
16641 {
16642 cycle_restore ();
16643 }
16644 }
16645
16646 // finally save left hashes
16647
16648 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16649 {
16650 save_hash ();
16651 }
16652
16653 /**
16654 * Clean up
16655 */
16656
16657 if (benchmark == 1)
16658 {
16659 status_benchmark ();
16660
16661 log_info ("");
16662 }
16663 else
16664 {
16665 if (quiet == 0) clear_prompt ();
16666
16667 if (quiet == 0) log_info ("");
16668
16669 if (status == 1)
16670 {
16671 status_display ();
16672 }
16673 else
16674 {
16675 if (quiet == 0) status_display ();
16676 }
16677
16678 if (quiet == 0) log_info ("");
16679 }
16680
16681 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16682 {
16683 hc_device_param_t *device_param = &data.devices_param[device_id];
16684
16685 if (device_param->skipped) continue;
16686
16687 local_free (device_param->result);
16688
16689 local_free (device_param->combs_buf);
16690
16691 local_free (device_param->hooks_buf);
16692
16693 local_free (device_param->device_name);
16694
16695 local_free (device_param->device_name_chksum);
16696
16697 local_free (device_param->device_version);
16698
16699 local_free (device_param->driver_version);
16700
16701 if (device_param->pws_buf) myfree (device_param->pws_buf);
16702 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16703 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16704 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16705 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16706 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16707 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16708 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16709 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16710 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16711 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16712 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16713 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16714 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16715 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16716 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16717 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16718 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16719 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16720 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16721 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16722 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16723 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16724 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16725 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16726 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16727 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16728 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16729 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16730
16731 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16732 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16733 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16734 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16735 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16736 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16737 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16738 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16739 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16740 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16741 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16742
16743 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16744 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16745 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16746
16747 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16748 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16749 }
16750
16751 // reset default fan speed
16752
16753 #ifdef HAVE_HWMON
16754 if (gpu_temp_disable == 0)
16755 {
16756 #ifdef HAVE_ADL
16757 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16758 {
16759 hc_thread_mutex_lock (mux_adl);
16760
16761 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16762 {
16763 hc_device_param_t *device_param = &data.devices_param[device_id];
16764
16765 if (device_param->skipped) continue;
16766
16767 if (data.hm_device[device_id].fan_supported == 1)
16768 {
16769 int fanspeed = temp_retain_fanspeed_value[device_id];
16770
16771 if (fanspeed == -1) continue;
16772
16773 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16774
16775 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16776 }
16777 }
16778
16779 hc_thread_mutex_unlock (mux_adl);
16780 }
16781 #endif // HAVE_ADL
16782 }
16783
16784 #ifdef HAVE_ADL
16785 // reset power tuning
16786
16787 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16788 {
16789 hc_thread_mutex_lock (mux_adl);
16790
16791 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16792 {
16793 hc_device_param_t *device_param = &data.devices_param[device_id];
16794
16795 if (device_param->skipped) continue;
16796
16797 if (data.hm_device[device_id].od_version == 6)
16798 {
16799 // check powertune capabilities first, if not available then skip device
16800
16801 int powertune_supported = 0;
16802
16803 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16804 {
16805 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16806
16807 return (-1);
16808 }
16809
16810 if (powertune_supported != 0)
16811 {
16812 // powercontrol settings
16813
16814 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)
16815 {
16816 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16817
16818 return (-1);
16819 }
16820
16821 // clocks
16822
16823 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16824
16825 performance_state->iNumberOfPerformanceLevels = 2;
16826
16827 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16828 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16829 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16830 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16831
16832 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)
16833 {
16834 log_info ("ERROR: Failed to restore ADL performance state");
16835
16836 return (-1);
16837 }
16838
16839 local_free (performance_state);
16840 }
16841 }
16842 }
16843
16844 hc_thread_mutex_unlock (mux_adl);
16845 }
16846 #endif // HAVE_ADL
16847
16848 if (gpu_temp_disable == 0)
16849 {
16850 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16851 if (data.hm_nv)
16852 {
16853 #if defined(LINUX) && defined(HAVE_NVML)
16854
16855 hm_NVML_nvmlShutdown (data.hm_nv);
16856
16857 nvml_close (data.hm_nv);
16858
16859 #elif defined(WIN) && (HAVE_NVAPI)
16860
16861 hm_NvAPI_Unload (data.hm_nv);
16862
16863 nvapi_close (data.hm_nv);
16864
16865 #endif
16866
16867 data.hm_nv = NULL;
16868 }
16869 #endif
16870
16871 #ifdef HAVE_ADL
16872 if (data.hm_amd)
16873 {
16874 hm_ADL_Main_Control_Destroy (data.hm_amd);
16875
16876 adl_close (data.hm_amd);
16877 data.hm_amd = NULL;
16878 }
16879 #endif
16880 }
16881 #endif // HAVE_HWMON
16882
16883 // free memory
16884
16885 local_free (masks);
16886
16887 local_free (dictstat_base);
16888
16889 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16890 {
16891 pot_t *pot_ptr = &pot[pot_pos];
16892
16893 hash_t *hash = &pot_ptr->hash;
16894
16895 local_free (hash->digest);
16896
16897 if (isSalted)
16898 {
16899 local_free (hash->salt);
16900 }
16901 }
16902
16903 local_free (pot);
16904
16905 local_free (all_kernel_rules_cnt);
16906 local_free (all_kernel_rules_buf);
16907
16908 local_free (wl_data->buf);
16909 local_free (wl_data);
16910
16911 local_free (bitmap_s1_a);
16912 local_free (bitmap_s1_b);
16913 local_free (bitmap_s1_c);
16914 local_free (bitmap_s1_d);
16915 local_free (bitmap_s2_a);
16916 local_free (bitmap_s2_b);
16917 local_free (bitmap_s2_c);
16918 local_free (bitmap_s2_d);
16919
16920 #ifdef HAVE_HWMON
16921 local_free (temp_retain_fanspeed_value);
16922 #ifdef HAVE_ADL
16923 local_free (od_clock_mem_status);
16924 local_free (od_power_control_status);
16925 #endif // ADL
16926 #endif
16927
16928 global_free (devices_param);
16929
16930 global_free (kernel_rules_buf);
16931
16932 global_free (root_css_buf);
16933 global_free (markov_css_buf);
16934
16935 global_free (digests_buf);
16936 global_free (digests_shown);
16937 global_free (digests_shown_tmp);
16938
16939 global_free (salts_buf);
16940 global_free (salts_shown);
16941
16942 global_free (esalts_buf);
16943
16944 global_free (words_progress_done);
16945 global_free (words_progress_rejected);
16946 global_free (words_progress_restored);
16947
16948 if (pot_fp) fclose (pot_fp);
16949
16950 if (data.devices_status == STATUS_QUIT) break;
16951 }
16952
16953 // destroy others mutex
16954
16955 hc_thread_mutex_delete (mux_dispatcher);
16956 hc_thread_mutex_delete (mux_counter);
16957 hc_thread_mutex_delete (mux_display);
16958 hc_thread_mutex_delete (mux_adl);
16959
16960 // free memory
16961
16962 local_free (eff_restore_file);
16963 local_free (new_restore_file);
16964
16965 local_free (rd);
16966
16967 // tuning db
16968
16969 tuning_db_destroy (tuning_db);
16970
16971 // loopback
16972
16973 local_free (loopback_file);
16974
16975 if (loopback == 1) unlink (loopback_file);
16976
16977 // induction directory
16978
16979 if (induction_dir == NULL)
16980 {
16981 if (attack_mode != ATTACK_MODE_BF)
16982 {
16983 if (rmdir (induction_directory) == -1)
16984 {
16985 if (errno == ENOENT)
16986 {
16987 // good, we can ignore
16988 }
16989 else if (errno == ENOTEMPTY)
16990 {
16991 // good, we can ignore
16992 }
16993 else
16994 {
16995 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16996
16997 return (-1);
16998 }
16999 }
17000
17001 local_free (induction_directory);
17002 }
17003 }
17004
17005 // outfile-check directory
17006
17007 if (outfile_check_dir == NULL)
17008 {
17009 if (rmdir (outfile_check_directory) == -1)
17010 {
17011 if (errno == ENOENT)
17012 {
17013 // good, we can ignore
17014 }
17015 else if (errno == ENOTEMPTY)
17016 {
17017 // good, we can ignore
17018 }
17019 else
17020 {
17021 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17022
17023 return (-1);
17024 }
17025 }
17026
17027 local_free (outfile_check_directory);
17028 }
17029
17030 time_t proc_stop;
17031
17032 time (&proc_stop);
17033
17034 logfile_top_uint (proc_start);
17035 logfile_top_uint (proc_stop);
17036
17037 logfile_top_msg ("STOP");
17038
17039 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17040 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17041
17042 if (data.ocl) ocl_close (data.ocl);
17043
17044 if (data.devices_status == STATUS_ABORTED) return 2;
17045 if (data.devices_status == STATUS_QUIT) return 2;
17046 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17047 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17048 if (data.devices_status == STATUS_CRACKED) return 0;
17049
17050 return -1;
17051 }
Hashcat additions to support pwdhash