projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Get rid of old pw_cache mechanism to control host-based vector data-types
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define BENCHMARK_REPEATS 2
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMT_HASHCAT 0
101 #define HLFMT_PWDUMP 1
102 #define HLFMT_PASSWD 2
103 #define HLFMT_SHADOW 3
104 #define HLFMT_DCC 4
105 #define HLFMT_DCC2 5
106 #define HLFMT_NETNTLM1 7
107 #define HLFMT_NETNTLM2 8
108 #define HLFMT_NSLDAP 9
109 #define HLFMT_NSLDAPS 10
110 #define HLFMTS_CNT 11
111
112 #define ATTACK_MODE_STRAIGHT 0
113 #define ATTACK_MODE_COMBI 1
114 #define ATTACK_MODE_TOGGLE 2
115 #define ATTACK_MODE_BF 3
116 #define ATTACK_MODE_PERM 4
117 #define ATTACK_MODE_TABLE 5
118 #define ATTACK_MODE_HYBRID1 6
119 #define ATTACK_MODE_HYBRID2 7
120 #define ATTACK_MODE_NONE 100
121
122 #define ATTACK_KERN_STRAIGHT 0
123 #define ATTACK_KERN_COMBI 1
124 #define ATTACK_KERN_BF 3
125 #define ATTACK_KERN_NONE 100
126
127 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
128 #define ATTACK_EXEC_INSIDE_KERNEL 11
129
130 #define COMBINATOR_MODE_BASE_LEFT 10001
131 #define COMBINATOR_MODE_BASE_RIGHT 10002
132
133 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
134 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
135
136 #define MAX_CUT_TRIES 4
137
138 #define MAX_DICTSTAT 10000
139
140 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 131
141
142 #define global_free(attr) \
143 { \
144 myfree ((void *) data.attr); \
145 \
146 data.attr = NULL; \
147 }
148
149 #define local_free(attr) \
150 { \
151 myfree ((void *) attr); \
152 \
153 attr = NULL; \
154 }
155
156 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
157 {
158 900,
159 0,
160 5100,
161 100,
162 1400,
163 10800,
164 1700,
165 5000,
166 10100,
167 6000,
168 6100,
169 6900,
170 11700,
171 11800,
172 400,
173 8900,
174 11900,
175 12000,
176 10900,
177 12100,
178 23,
179 2500,
180 5300,
181 5400,
182 5500,
183 5600,
184 7300,
185 7500,
186 13100,
187 8300,
188 11100,
189 11200,
190 11400,
191 121,
192 2611,
193 2711,
194 2811,
195 8400,
196 11,
197 2612,
198 7900,
199 21,
200 11000,
201 124,
202 10000,
203 3711,
204 7600,
205 12,
206 131,
207 132,
208 1731,
209 200,
210 300,
211 3100,
212 112,
213 12300,
214 8000,
215 141,
216 1441,
217 1600,
218 12600,
219 1421,
220 101,
221 111,
222 1711,
223 3000,
224 1000,
225 1100,
226 2100,
227 12800,
228 1500,
229 12400,
230 500,
231 3200,
232 7400,
233 1800,
234 122,
235 1722,
236 7100,
237 6300,
238 6700,
239 6400,
240 6500,
241 2400,
242 2410,
243 5700,
244 9200,
245 9300,
246 22,
247 501,
248 5800,
249 8100,
250 8500,
251 7200,
252 9900,
253 7700,
254 7800,
255 10300,
256 8600,
257 8700,
258 9100,
259 133,
260 11600,
261 12500,
262 13000,
263 6211,
264 6221,
265 6231,
266 6241,
267 8800,
268 12900,
269 12200,
270 9700,
271 9710,
272 9800,
273 9810,
274 9400,
275 9500,
276 9600,
277 10400,
278 10410,
279 10500,
280 10600,
281 10700,
282 9000,
283 5200,
284 6800,
285 6600,
286 8200,
287 11300,
288 12700
289 };
290
291 /**
292 * types
293 */
294
295 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
296
297 /**
298 * globals
299 */
300
301 static unsigned int full01 = 0x01010101;
302 static unsigned int full80 = 0x80808080;
303
304 int SUPPRESS_OUTPUT = 0;
305
306 hc_thread_mutex_t mux_adl;
307 hc_thread_mutex_t mux_counter;
308 hc_thread_mutex_t mux_dispatcher;
309 hc_thread_mutex_t mux_display;
310
311 hc_global_data_t data;
312
313 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
314
315 const char *USAGE_MINI[] =
316 {
317 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
318 "",
319 "Try --help for more help.",
320 NULL
321 };
322
323 const char *USAGE_BIG[] =
324 {
325 "%s, advanced password recovery",
326 "",
327 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
328 "",
329 "=======",
330 "Options",
331 "=======",
332 "",
333 "* General:",
334 "",
335 " -m, --hash-type=NUM Hash-type, see references below",
336 " -a, --attack-mode=NUM Attack-mode, see references below",
337 " -V, --version Print version",
338 " -h, --help Print help",
339 " --quiet Suppress output",
340 "",
341 "* Misc:",
342 "",
343 " --hex-charset Assume charset is given in hex",
344 " --hex-salt Assume salt is given in hex",
345 " --hex-wordlist Assume words in wordlist is given in hex",
346 " --force Ignore warnings",
347 " --status Enable automatic update of the status-screen",
348 " --status-timer=NUM Seconds between status-screen update",
349 " --status-automat Display the status view in a machine readable format",
350 " --loopback Add new plains to induct directory",
351 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
352 "",
353 "* Markov:",
354 "",
355 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
356 " --markov-disable Disables markov-chains, emulates classic brute-force",
357 " --markov-classic Enables classic markov-chains, no per-position enhancement",
358 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
359 "",
360 "* Session:",
361 "",
362 " --runtime=NUM Abort session after NUM seconds of runtime",
363 " --session=STR Define specific session name",
364 " --restore Restore session from --session",
365 " --restore-disable Do not write restore file",
366 "",
367 "* Files:",
368 "",
369 " -o, --outfile=FILE Define outfile for recovered hash",
370 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
371 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
372 " --outfile-check-timer=NUM Seconds between outfile checks",
373 " -p, --separator=CHAR Separator char for hashlists and outfile",
374 " --show Show cracked passwords only",
375 " --left Show un-cracked passwords only",
376 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
377 " --remove Enable remove of hash once it is cracked",
378 " --remove-timer=NUM Update input hash file each NUM seconds",
379 " --potfile-disable Do not write potfile",
380 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
381 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
382 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
383 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
384 " --logfile-disable Disable the logfile",
385 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
386 "",
387 "* Resources:",
388 "",
389 " -b, --benchmark Run benchmark",
390 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
391 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
392 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
393 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
394 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
395 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
396 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
397 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
398 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
399 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
400 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
401 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
402 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
403 #ifdef HAVE_HWMON
404 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
405 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
406 #ifdef HAVE_ADL
407 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
408 #endif
409 #endif
410 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
411 "",
412 "* Distributed:",
413 "",
414 " -s, --skip=NUM Skip number of words",
415 " -l, --limit=NUM Limit number of words",
416 " --keyspace Show keyspace base:mod values and quit",
417 "",
418 "* Rules:",
419 "",
420 " -j, --rule-left=RULE Single rule applied to each word from left dict",
421 " -k, --rule-right=RULE Single rule applied to each word from right dict",
422 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
423 " -g, --generate-rules=NUM Generate NUM random rules",
424 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
425 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
426 " --generate-rules-seed=NUM Force RNG seed to NUM",
427 "",
428 "* Custom charsets:",
429 "",
430 " -1, --custom-charset1=CS User-defined charsets",
431 " -2, --custom-charset2=CS Example:",
432 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
433 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
434 "",
435 "* Increment:",
436 "",
437 " -i, --increment Enable increment mode",
438 " --increment-min=NUM Start incrementing at NUM",
439 " --increment-max=NUM Stop incrementing at NUM",
440 "",
441 "==========",
442 "References",
443 "==========",
444 "",
445 "* Workload Profile:",
446 "",
447 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
448 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
449 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
450 "",
451 "* OpenCL device-types:",
452 "",
453 " 1 = CPU devices",
454 " 2 = GPU devices",
455 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
456 "",
457 "* Outfile Formats:",
458 "",
459 " 1 = hash[:salt]",
460 " 2 = plain",
461 " 3 = hash[:salt]:plain",
462 " 4 = hex_plain",
463 " 5 = hash[:salt]:hex_plain",
464 " 6 = plain:hex_plain",
465 " 7 = hash[:salt]:plain:hex_plain",
466 " 8 = crackpos",
467 " 9 = hash[:salt]:crackpos",
468 " 10 = plain:crackpos",
469 " 11 = hash[:salt]:plain:crackpos",
470 " 12 = hex_plain:crackpos",
471 " 13 = hash[:salt]:hex_plain:crackpos",
472 " 14 = plain:hex_plain:crackpos",
473 " 15 = hash[:salt]:plain:hex_plain:crackpos",
474 "",
475 "* Debug mode output formats (for hybrid mode only, by using rules):",
476 "",
477 " 1 = save finding rule",
478 " 2 = save original word",
479 " 3 = save original word and finding rule",
480 " 4 = save original word, finding rule and modified plain",
481 "",
482 "* Built-in charsets:",
483 "",
484 " ?l = abcdefghijklmnopqrstuvwxyz",
485 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
486 " ?d = 0123456789",
487 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
488 " ?a = ?l?u?d?s",
489 " ?b = 0x00 - 0xff",
490 "",
491 "* Attack modes:",
492 "",
493 " 0 = Straight",
494 " 1 = Combination",
495 " 3 = Brute-force",
496 " 6 = Hybrid dict + mask",
497 " 7 = Hybrid mask + dict",
498 "",
499 "* Hash types:",
500 "",
501 "[[ Roll-your-own: Raw Hashes ]]",
502 "",
503 " 900 = MD4",
504 " 0 = MD5",
505 " 5100 = Half MD5",
506 " 100 = SHA1",
507 " 10800 = SHA-384",
508 " 1400 = SHA-256",
509 " 1700 = SHA-512",
510 " 5000 = SHA-3(Keccak)",
511 " 10100 = SipHash",
512 " 6000 = RipeMD160",
513 " 6100 = Whirlpool",
514 " 6900 = GOST R 34.11-94",
515 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
516 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
517 "",
518 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
519 "",
520 " 10 = md5($pass.$salt)",
521 " 20 = md5($salt.$pass)",
522 " 30 = md5(unicode($pass).$salt)",
523 " 40 = md5($salt.unicode($pass))",
524 " 3800 = md5($salt.$pass.$salt)",
525 " 3710 = md5($salt.md5($pass))",
526 " 2600 = md5(md5($pass)",
527 " 4300 = md5(strtoupper(md5($pass)))",
528 " 4400 = md5(sha1($pass))",
529 " 110 = sha1($pass.$salt)",
530 " 120 = sha1($salt.$pass)",
531 " 130 = sha1(unicode($pass).$salt)",
532 " 140 = sha1($salt.unicode($pass))",
533 " 4500 = sha1(sha1($pass)",
534 " 4700 = sha1(md5($pass))",
535 " 4900 = sha1($salt.$pass.$salt)",
536 " 1410 = sha256($pass.$salt)",
537 " 1420 = sha256($salt.$pass)",
538 " 1430 = sha256(unicode($pass).$salt)",
539 " 1440 = sha256($salt.unicode($pass))",
540 " 1710 = sha512($pass.$salt)",
541 " 1720 = sha512($salt.$pass)",
542 " 1730 = sha512(unicode($pass).$salt)",
543 " 1740 = sha512($salt.unicode($pass))",
544 "",
545 "[[ Roll-your-own: Authenticated Hashes ]]",
546 "",
547 " 50 = HMAC-MD5 (key = $pass)",
548 " 60 = HMAC-MD5 (key = $salt)",
549 " 150 = HMAC-SHA1 (key = $pass)",
550 " 160 = HMAC-SHA1 (key = $salt)",
551 " 1450 = HMAC-SHA256 (key = $pass)",
552 " 1460 = HMAC-SHA256 (key = $salt)",
553 " 1750 = HMAC-SHA512 (key = $pass)",
554 " 1760 = HMAC-SHA512 (key = $salt)",
555 "",
556 "[[ Generic KDF ]]",
557 "",
558 " 400 = phpass",
559 " 8900 = scrypt",
560 " 11900 = PBKDF2-HMAC-MD5",
561 " 12000 = PBKDF2-HMAC-SHA1",
562 " 10900 = PBKDF2-HMAC-SHA256",
563 " 12100 = PBKDF2-HMAC-SHA512",
564 "",
565 "[[ Network protocols, Challenge-Response ]]",
566 "",
567 " 23 = Skype",
568 " 2500 = WPA/WPA2",
569 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
570 " 5300 = IKE-PSK MD5",
571 " 5400 = IKE-PSK SHA1",
572 " 5500 = NetNTLMv1",
573 " 5500 = NetNTLMv1 + ESS",
574 " 5600 = NetNTLMv2",
575 " 7300 = IPMI2 RAKP HMAC-SHA1",
576 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
577 " 8300 = DNSSEC (NSEC3)",
578 " 10200 = Cram MD5",
579 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
580 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
581 " 11400 = SIP digest authentication (MD5)",
582 " 13100 = Kerberos 5 TGS-REP etype 23",
583 "",
584 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
585 "",
586 " 121 = SMF (Simple Machines Forum)",
587 " 400 = phpBB3",
588 " 2611 = vBulletin < v3.8.5",
589 " 2711 = vBulletin > v3.8.5",
590 " 2811 = MyBB",
591 " 2811 = IPB (Invison Power Board)",
592 " 8400 = WBB3 (Woltlab Burning Board)",
593 " 11 = Joomla < 2.5.18",
594 " 400 = Joomla > 2.5.18",
595 " 400 = Wordpress",
596 " 2612 = PHPS",
597 " 7900 = Drupal7",
598 " 21 = osCommerce",
599 " 21 = xt:Commerce",
600 " 11000 = PrestaShop",
601 " 124 = Django (SHA-1)",
602 " 10000 = Django (PBKDF2-SHA256)",
603 " 3711 = Mediawiki B type",
604 " 7600 = Redmine",
605 "",
606 "[[ Database Server ]]",
607 "",
608 " 12 = PostgreSQL",
609 " 131 = MSSQL(2000)",
610 " 132 = MSSQL(2005)",
611 " 1731 = MSSQL(2012)",
612 " 1731 = MSSQL(2014)",
613 " 200 = MySQL323",
614 " 300 = MySQL4.1/MySQL5",
615 " 3100 = Oracle H: Type (Oracle 7+)",
616 " 112 = Oracle S: Type (Oracle 11+)",
617 " 12300 = Oracle T: Type (Oracle 12+)",
618 " 8000 = Sybase ASE",
619 "",
620 "[[ HTTP, SMTP, LDAP Server ]]",
621 "",
622 " 141 = EPiServer 6.x < v4",
623 " 1441 = EPiServer 6.x > v4",
624 " 1600 = Apache $apr1$",
625 " 12600 = ColdFusion 10+",
626 " 1421 = hMailServer",
627 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
628 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
629 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
630 "",
631 "[[ Checksums ]]",
632 "",
633 " 11500 = CRC32",
634 "",
635 "[[ Operating-Systems ]]",
636 "",
637 " 3000 = LM",
638 " 1000 = NTLM",
639 " 1100 = Domain Cached Credentials (DCC), MS Cache",
640 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
641 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
642 " 1500 = descrypt, DES(Unix), Traditional DES",
643 " 12400 = BSDiCrypt, Extended DES",
644 " 500 = md5crypt $1$, MD5(Unix)",
645 " 3200 = bcrypt $2*$, Blowfish(Unix)",
646 " 7400 = sha256crypt $5$, SHA256(Unix)",
647 " 1800 = sha512crypt $6$, SHA512(Unix)",
648 " 122 = OSX v10.4",
649 " 122 = OSX v10.5",
650 " 122 = OSX v10.6",
651 " 1722 = OSX v10.7",
652 " 7100 = OSX v10.8",
653 " 7100 = OSX v10.9",
654 " 7100 = OSX v10.10",
655 " 6300 = AIX {smd5}",
656 " 6700 = AIX {ssha1}",
657 " 6400 = AIX {ssha256}",
658 " 6500 = AIX {ssha512}",
659 " 2400 = Cisco-PIX",
660 " 2410 = Cisco-ASA",
661 " 500 = Cisco-IOS $1$",
662 " 5700 = Cisco-IOS $4$",
663 " 9200 = Cisco-IOS $8$",
664 " 9300 = Cisco-IOS $9$",
665 " 22 = Juniper Netscreen/SSG (ScreenOS)",
666 " 501 = Juniper IVE",
667 " 5800 = Android PIN",
668 " 8100 = Citrix Netscaler",
669 " 8500 = RACF",
670 " 7200 = GRUB 2",
671 " 9900 = Radmin2",
672 "",
673 "[[ Enterprise Application Software (EAS) ]]",
674 "",
675 " 7700 = SAP CODVN B (BCODE)",
676 " 7800 = SAP CODVN F/G (PASSCODE)",
677 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
678 " 8600 = Lotus Notes/Domino 5",
679 " 8700 = Lotus Notes/Domino 6",
680 " 9100 = Lotus Notes/Domino 8",
681 " 133 = PeopleSoft",
682 "",
683 "[[ Archives ]]",
684 "",
685 " 11600 = 7-Zip",
686 " 12500 = RAR3-hp",
687 " 13000 = RAR5",
688 "",
689 "[[ Full-Disk encryptions (FDE) ]]",
690 "",
691 " 62XY = TrueCrypt 5.0+",
692 " X = 1 = PBKDF2-HMAC-RipeMD160",
693 " X = 2 = PBKDF2-HMAC-SHA512",
694 " X = 3 = PBKDF2-HMAC-Whirlpool",
695 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
696 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
697 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
698 " Y = 3 = XTS 1536 bit (Ciphers: All)",
699 " 8800 = Android FDE < v4.3",
700 " 12900 = Android FDE (Samsung DEK)",
701 " 12200 = eCryptfs",
702 "",
703 "[[ Documents ]]",
704 "",
705 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
706 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
707 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
708 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
709 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
710 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
711 " 9400 = MS Office 2007",
712 " 9500 = MS Office 2010",
713 " 9600 = MS Office 2013",
714 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
715 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
716 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
717 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
718 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
719 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
720 "",
721 "[[ Password Managers ]]",
722 "",
723 " 9000 = Password Safe v2",
724 " 5200 = Password Safe v3",
725 " 6800 = Lastpass",
726 " 6600 = 1Password, agilekeychain",
727 " 8200 = 1Password, cloudkeychain",
728 " 11300 = Bitcoin/Litecoin wallet.dat",
729 " 12700 = Blockchain, My Wallet",
730 "",
731 NULL
732 };
733
734 /**
735 * oclHashcat specific functions
736 */
737
738 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
739 {
740 int exec_pos = (int) device_param->exec_pos - last_num_entries;
741
742 if (exec_pos < 0) exec_pos += EXEC_CACHE;
743
744 double exec_ms_sum = 0;
745
746 int exec_ms_cnt = 0;
747
748 for (int i = 0; i < last_num_entries; i++)
749 {
750 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
751
752 if (exec_ms)
753 {
754 exec_ms_sum += exec_ms;
755
756 exec_ms_cnt++;
757 }
758 }
759
760 if (exec_ms_cnt == 0) return 0;
761
762 return exec_ms_sum / exec_ms_cnt;
763 }
764
765 void status_display_automat ()
766 {
767 FILE *out = stdout;
768
769 fprintf (out, "STATUS\t%u\t", data.devices_status);
770
771 /**
772 * speed new
773 */
774
775 fprintf (out, "SPEED\t");
776
777 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
778 {
779 hc_device_param_t *device_param = &data.devices_param[device_id];
780
781 if (device_param->skipped) continue;
782
783 u64 speed_cnt = 0;
784 float speed_ms = 0;
785
786 for (int i = 0; i < SPEED_CACHE; i++)
787 {
788 float rec_ms;
789
790 hc_timer_get (device_param->speed_rec[i], rec_ms);
791
792 if (rec_ms > SPEED_MAXAGE) continue;
793
794 speed_cnt += device_param->speed_cnt[i];
795 speed_ms += device_param->speed_ms[i];
796 }
797
798 speed_cnt /= SPEED_CACHE;
799 speed_ms /= SPEED_CACHE;
800
801 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
802 }
803
804 /**
805 * exec time
806 */
807
808 fprintf (out, "EXEC_RUNTIME\t");
809
810 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
811 {
812 hc_device_param_t *device_param = &data.devices_param[device_id];
813
814 if (device_param->skipped) continue;
815
816 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
817
818 fprintf (out, "%f\t", exec_ms_avg);
819 }
820
821 /**
822 * words_cur
823 */
824
825 u64 words_cur = get_lowest_words_done ();
826
827 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
828
829 /**
830 * counter
831 */
832
833 uint salts_left = data.salts_cnt - data.salts_done;
834
835 if (salts_left == 0) salts_left = 1;
836
837 u64 progress_total = data.words_cnt * salts_left;
838
839 u64 all_done = 0;
840 u64 all_rejected = 0;
841 u64 all_restored = 0;
842
843 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
844 {
845 if (salts_left > 1)
846 {
847 // otherwise the final cracked status shows 0/XXX progress
848
849 if (data.salts_shown[salt_pos] == 1) continue;
850 }
851
852 all_done += data.words_progress_done[salt_pos];
853 all_rejected += data.words_progress_rejected[salt_pos];
854 all_restored += data.words_progress_restored[salt_pos];
855 }
856
857 u64 progress_cur = all_restored + all_done + all_rejected;
858 u64 progress_end = progress_total;
859
860 u64 progress_skip = 0;
861
862 if (data.skip)
863 {
864 progress_skip = MIN (data.skip, data.words_base) * salts_left;
865
866 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
867 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
868 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
869 }
870
871 if (data.limit)
872 {
873 progress_end = MIN (data.limit, data.words_base) * salts_left;
874
875 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
876 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
877 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
878 }
879
880 u64 progress_cur_relative_skip = progress_cur - progress_skip;
881 u64 progress_end_relative_skip = progress_end - progress_skip;
882
883 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
884
885 /**
886 * cracks
887 */
888
889 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
890 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
891
892 /**
893 * temperature
894 */
895
896 #ifdef HAVE_HWMON
897 if (data.gpu_temp_disable == 0)
898 {
899 fprintf (out, "TEMP\t");
900
901 hc_thread_mutex_lock (mux_adl);
902
903 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
904 {
905 hc_device_param_t *device_param = &data.devices_param[device_id];
906
907 if (device_param->skipped) continue;
908
909 int temp = hm_get_temperature_with_device_id (device_id);
910
911 fprintf (out, "%d\t", temp);
912 }
913
914 hc_thread_mutex_unlock (mux_adl);
915 }
916 #endif // HAVE_HWMON
917
918 /**
919 * flush
920 */
921
922 #ifdef _WIN
923 fputc ('\r', out);
924 fputc ('\n', out);
925 #endif
926
927 #ifdef _POSIX
928 fputc ('\n', out);
929 #endif
930
931 fflush (out);
932 }
933
934 void status_display ()
935 {
936 if (data.devices_status == STATUS_INIT) return;
937 if (data.devices_status == STATUS_STARTING) return;
938 if (data.devices_status == STATUS_BYPASS) return;
939
940 if (data.status_automat == 1)
941 {
942 status_display_automat ();
943
944 return;
945 }
946
947 char tmp_buf[1000] = { 0 };
948
949 uint tmp_len = 0;
950
951 log_info ("Session.Name...: %s", data.session);
952
953 char *status_type = strstatus (data.devices_status);
954
955 uint hash_mode = data.hash_mode;
956
957 char *hash_type = strhashtype (hash_mode); // not a bug
958
959 log_info ("Status.........: %s", status_type);
960
961 /**
962 * show rules
963 */
964
965 if (data.rp_files_cnt)
966 {
967 uint i;
968
969 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
970 {
971 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
972 }
973
974 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
975
976 log_info ("Rules.Type.....: %s", tmp_buf);
977
978 tmp_len = 0;
979 }
980
981 if (data.rp_gen)
982 {
983 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
984
985 if (data.rp_gen_seed)
986 {
987 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
988 }
989 }
990
991 /**
992 * show input
993 */
994
995 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
996 {
997 if (data.wordlist_mode == WL_MODE_FILE)
998 {
999 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1000 }
1001 else if (data.wordlist_mode == WL_MODE_STDIN)
1002 {
1003 log_info ("Input.Mode.....: Pipe");
1004 }
1005 }
1006 else if (data.attack_mode == ATTACK_MODE_COMBI)
1007 {
1008 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1009 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1010 }
1011 else if (data.attack_mode == ATTACK_MODE_BF)
1012 {
1013 char *mask = data.mask;
1014
1015 if (mask != NULL)
1016 {
1017 uint mask_len = data.css_cnt;
1018
1019 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1020
1021 if (mask_len > 0)
1022 {
1023 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1024 {
1025 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1026 {
1027 mask_len -= data.salts_buf[0].salt_len;
1028 }
1029 }
1030
1031 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1032
1033 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1034 }
1035
1036 if (data.maskcnt > 1)
1037 {
1038 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1039
1040 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1041 }
1042
1043 log_info ("Input.Mode.....: %s", tmp_buf);
1044 }
1045
1046 tmp_len = 0;
1047 }
1048 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1049 {
1050 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1051 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1052 }
1053 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1054 {
1055 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1056 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1057 }
1058
1059 if (data.digests_cnt == 1)
1060 {
1061 if (data.hash_mode == 2500)
1062 {
1063 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1064
1065 uint pke[25] = { 0 };
1066
1067 char *pke_ptr = (char *) pke;
1068
1069 for (uint i = 0; i < 25; i++)
1070 {
1071 pke[i] = byte_swap_32 (wpa->pke[i]);
1072 }
1073
1074 char mac1[6] = { 0 };
1075 char mac2[6] = { 0 };
1076
1077 memcpy (mac1, pke_ptr + 23, 6);
1078 memcpy (mac2, pke_ptr + 29, 6);
1079
1080 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1081 (char *) data.salts_buf[0].salt_buf,
1082 mac1[0] & 0xff,
1083 mac1[1] & 0xff,
1084 mac1[2] & 0xff,
1085 mac1[3] & 0xff,
1086 mac1[4] & 0xff,
1087 mac1[5] & 0xff,
1088 mac2[0] & 0xff,
1089 mac2[1] & 0xff,
1090 mac2[2] & 0xff,
1091 mac2[3] & 0xff,
1092 mac2[4] & 0xff,
1093 mac2[5] & 0xff);
1094 }
1095 else if (data.hash_mode == 5200)
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else if (data.hash_mode == 9000)
1100 {
1101 log_info ("Hash.Target....: File (%s)", data.hashfile);
1102 }
1103 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 else
1108 {
1109 char out_buf[4096] = { 0 };
1110
1111 ascii_digest (out_buf, 0, 0);
1112
1113 // limit length
1114 if (strlen (out_buf) > 40)
1115 {
1116 out_buf[41] = '.';
1117 out_buf[42] = '.';
1118 out_buf[43] = '.';
1119 out_buf[44] = 0;
1120 }
1121
1122 log_info ("Hash.Target....: %s", out_buf);
1123 }
1124 }
1125 else
1126 {
1127 if (data.hash_mode == 3000)
1128 {
1129 char out_buf1[4096] = { 0 };
1130 char out_buf2[4096] = { 0 };
1131
1132 ascii_digest (out_buf1, 0, 0);
1133 ascii_digest (out_buf2, 0, 1);
1134
1135 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1136 }
1137 else
1138 {
1139 log_info ("Hash.Target....: File (%s)", data.hashfile);
1140 }
1141 }
1142
1143 log_info ("Hash.Type......: %s", hash_type);
1144
1145 /**
1146 * speed new
1147 */
1148
1149 u64 speed_cnt[DEVICES_MAX] = { 0 };
1150 float speed_ms[DEVICES_MAX] = { 0 };
1151
1152 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1153 {
1154 hc_device_param_t *device_param = &data.devices_param[device_id];
1155
1156 if (device_param->skipped) continue;
1157
1158 // we need to clear values (set to 0) because in case the device does
1159 // not get new candidates it idles around but speed display would
1160 // show it as working.
1161 // if we instantly set it to 0 after reading it happens that the
1162 // speed can be shown as zero if the users refreshes too fast.
1163 // therefore, we add a timestamp when a stat was recorded and if its
1164 // too old we will not use it
1165
1166 speed_cnt[device_id] = 0;
1167 speed_ms[device_id] = 0;
1168
1169 for (int i = 0; i < SPEED_CACHE; i++)
1170 {
1171 float rec_ms;
1172
1173 hc_timer_get (device_param->speed_rec[i], rec_ms);
1174
1175 if (rec_ms > SPEED_MAXAGE) continue;
1176
1177 speed_cnt[device_id] += device_param->speed_cnt[i];
1178 speed_ms[device_id] += device_param->speed_ms[i];
1179 }
1180
1181 speed_cnt[device_id] /= SPEED_CACHE;
1182 speed_ms[device_id] /= SPEED_CACHE;
1183 }
1184
1185 float hashes_all_ms = 0;
1186
1187 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1188
1189 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1190 {
1191 hc_device_param_t *device_param = &data.devices_param[device_id];
1192
1193 if (device_param->skipped) continue;
1194
1195 hashes_dev_ms[device_id] = 0;
1196
1197 if (speed_ms[device_id])
1198 {
1199 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1200
1201 hashes_all_ms += hashes_dev_ms[device_id];
1202 }
1203 }
1204
1205 /**
1206 * exec time
1207 */
1208
1209 double exec_all_ms[DEVICES_MAX] = { 0 };
1210
1211 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1212 {
1213 hc_device_param_t *device_param = &data.devices_param[device_id];
1214
1215 if (device_param->skipped) continue;
1216
1217 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1218
1219 exec_all_ms[device_id] = exec_ms_avg;
1220 }
1221
1222 /**
1223 * timers
1224 */
1225
1226 float ms_running = 0;
1227
1228 hc_timer_get (data.timer_running, ms_running);
1229
1230 float ms_paused = data.ms_paused;
1231
1232 if (data.devices_status == STATUS_PAUSED)
1233 {
1234 float ms_paused_tmp = 0;
1235
1236 hc_timer_get (data.timer_paused, ms_paused_tmp);
1237
1238 ms_paused += ms_paused_tmp;
1239 }
1240
1241 #ifdef WIN
1242
1243 __time64_t sec_run = ms_running / 1000;
1244
1245 #else
1246
1247 time_t sec_run = ms_running / 1000;
1248
1249 #endif
1250
1251 if (sec_run)
1252 {
1253 char display_run[32] = { 0 };
1254
1255 struct tm tm_run;
1256
1257 struct tm *tmp = NULL;
1258
1259 #ifdef WIN
1260
1261 tmp = _gmtime64 (&sec_run);
1262
1263 #else
1264
1265 tmp = gmtime (&sec_run);
1266
1267 #endif
1268
1269 if (tmp != NULL)
1270 {
1271 memset (&tm_run, 0, sizeof (tm_run));
1272
1273 memcpy (&tm_run, tmp, sizeof (tm_run));
1274
1275 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1276
1277 char *start = ctime (&data.proc_start);
1278
1279 size_t start_len = strlen (start);
1280
1281 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1282 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1283
1284 log_info ("Time.Started...: %s (%s)", start, display_run);
1285 }
1286 }
1287 else
1288 {
1289 log_info ("Time.Started...: 0 secs");
1290 }
1291
1292 /**
1293 * counters
1294 */
1295
1296 uint salts_left = data.salts_cnt - data.salts_done;
1297
1298 if (salts_left == 0) salts_left = 1;
1299
1300 u64 progress_total = data.words_cnt * salts_left;
1301
1302 u64 all_done = 0;
1303 u64 all_rejected = 0;
1304 u64 all_restored = 0;
1305
1306 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1307 {
1308 if (salts_left > 1)
1309 {
1310 // otherwise the final cracked status shows 0/XXX progress
1311
1312 if (data.salts_shown[salt_pos] == 1) continue;
1313 }
1314
1315 all_done += data.words_progress_done[salt_pos];
1316 all_rejected += data.words_progress_rejected[salt_pos];
1317 all_restored += data.words_progress_restored[salt_pos];
1318 }
1319
1320 u64 progress_cur = all_restored + all_done + all_rejected;
1321 u64 progress_end = progress_total;
1322
1323 u64 progress_skip = 0;
1324
1325 if (data.skip)
1326 {
1327 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1328
1329 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1330 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1331 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1332 }
1333
1334 if (data.limit)
1335 {
1336 progress_end = MIN (data.limit, data.words_base) * salts_left;
1337
1338 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1339 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1340 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1341 }
1342
1343 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1344 u64 progress_end_relative_skip = progress_end - progress_skip;
1345
1346 float speed_ms_real = ms_running - ms_paused;
1347 u64 speed_plains_real = all_done;
1348
1349 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1350 {
1351 if (data.devices_status != STATUS_CRACKED)
1352 {
1353 u64 words_per_ms = 0;
1354
1355 if (speed_plains_real && speed_ms_real)
1356 {
1357 words_per_ms = speed_plains_real / speed_ms_real;
1358 }
1359
1360 #ifdef WIN
1361 __time64_t sec_etc = 0;
1362 #else
1363 time_t sec_etc = 0;
1364 #endif
1365
1366 if (words_per_ms)
1367 {
1368 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1369
1370 u64 ms_left = progress_left_relative_skip / words_per_ms;
1371
1372 sec_etc = ms_left / 1000;
1373 }
1374
1375 if (sec_etc == 0)
1376 {
1377 log_info ("Time.Estimated.: 0 secs");
1378 }
1379 else if ((u64) sec_etc > ETC_MAX)
1380 {
1381 log_info ("Time.Estimated.: > 10 Years");
1382 }
1383 else
1384 {
1385 char display_etc[32] = { 0 };
1386
1387 struct tm tm_etc;
1388
1389 struct tm *tmp = NULL;
1390
1391 #ifdef WIN
1392
1393 tmp = _gmtime64 (&sec_etc);
1394
1395 #else
1396
1397 tmp = gmtime (&sec_etc);
1398
1399 #endif
1400
1401 if (tmp != NULL)
1402 {
1403 memset (&tm_etc, 0, sizeof (tm_etc));
1404
1405 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1406
1407 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1408
1409 time_t now;
1410
1411 time (&now);
1412
1413 now += sec_etc;
1414
1415 char *etc = ctime (&now);
1416
1417 size_t etc_len = strlen (etc);
1418
1419 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1420 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1421
1422 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1423 }
1424 }
1425 }
1426 }
1427
1428 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1429 {
1430 hc_device_param_t *device_param = &data.devices_param[device_id];
1431
1432 if (device_param->skipped) continue;
1433
1434 char display_dev_cur[16] = { 0 };
1435
1436 strncpy (display_dev_cur, "0.00", 4);
1437
1438 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1439
1440 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1441 }
1442
1443 char display_all_cur[16] = { 0 };
1444
1445 strncpy (display_all_cur, "0.00", 4);
1446
1447 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1448
1449 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1450
1451 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1452 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1453
1454 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1455
1456 // crack-per-time
1457
1458 if (data.digests_cnt > 100)
1459 {
1460 time_t now = time (NULL);
1461
1462 int cpt_cur_min = 0;
1463 int cpt_cur_hour = 0;
1464 int cpt_cur_day = 0;
1465
1466 for (int i = 0; i < CPT_BUF; i++)
1467 {
1468 const uint cracked = data.cpt_buf[i].cracked;
1469 const time_t timestamp = data.cpt_buf[i].timestamp;
1470
1471 if ((timestamp + 60) > now)
1472 {
1473 cpt_cur_min += cracked;
1474 }
1475
1476 if ((timestamp + 3600) > now)
1477 {
1478 cpt_cur_hour += cracked;
1479 }
1480
1481 if ((timestamp + 86400) > now)
1482 {
1483 cpt_cur_day += cracked;
1484 }
1485 }
1486
1487 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1488 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1489 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1490
1491 if ((data.cpt_start + 86400) < now)
1492 {
1493 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1494 cpt_cur_min,
1495 cpt_cur_hour,
1496 cpt_cur_day,
1497 cpt_avg_min,
1498 cpt_avg_hour,
1499 cpt_avg_day);
1500 }
1501 else if ((data.cpt_start + 3600) < now)
1502 {
1503 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1504 cpt_cur_min,
1505 cpt_cur_hour,
1506 cpt_avg_min,
1507 cpt_avg_hour,
1508 cpt_avg_day);
1509 }
1510 else if ((data.cpt_start + 60) < now)
1511 {
1512 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1513 cpt_cur_min,
1514 cpt_avg_min,
1515 cpt_avg_hour,
1516 cpt_avg_day);
1517 }
1518 else
1519 {
1520 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1521 cpt_avg_min,
1522 cpt_avg_hour,
1523 cpt_avg_day);
1524 }
1525 }
1526
1527 // Restore point
1528
1529 u64 restore_point = get_lowest_words_done ();
1530
1531 u64 restore_total = data.words_base;
1532
1533 float percent_restore = 0;
1534
1535 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1536
1537 if (progress_end_relative_skip)
1538 {
1539 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1540 {
1541 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1542 float percent_rejected = 0.0;
1543
1544 if (progress_cur)
1545 {
1546 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1547 }
1548
1549 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1550 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1551
1552 if (data.restore_disable == 0)
1553 {
1554 if (percent_finished != 1)
1555 {
1556 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1557 }
1558 }
1559 }
1560 }
1561 else
1562 {
1563 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1564 {
1565 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1566 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1567
1568 if (data.restore_disable == 0)
1569 {
1570 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1571 }
1572 }
1573 else
1574 {
1575 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1576 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1577
1578 // --restore not allowed if stdin is used -- really? why?
1579
1580 //if (data.restore_disable == 0)
1581 //{
1582 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1583 //}
1584 }
1585 }
1586
1587 #ifdef HAVE_HWMON
1588 if (data.gpu_temp_disable == 0)
1589 {
1590 hc_thread_mutex_lock (mux_adl);
1591
1592 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1593 {
1594 hc_device_param_t *device_param = &data.devices_param[device_id];
1595
1596 if (device_param->skipped) continue;
1597
1598 #define HM_STR_BUF_SIZE 255
1599
1600 if (data.hm_device[device_id].fan_supported == 1)
1601 {
1602 char utilization[HM_STR_BUF_SIZE] = { 0 };
1603 char temperature[HM_STR_BUF_SIZE] = { 0 };
1604 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1605
1606 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1607 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1608
1609 if (device_param->vendor_id == VENDOR_ID_AMD)
1610 {
1611 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1612 }
1613 else if (device_param->vendor_id == VENDOR_ID_NV)
1614 {
1615 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1616 }
1617
1618 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1619 }
1620 else
1621 {
1622 char utilization[HM_STR_BUF_SIZE] = { 0 };
1623 char temperature[HM_STR_BUF_SIZE] = { 0 };
1624
1625 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1626 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1627
1628 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1629 }
1630 }
1631
1632 hc_thread_mutex_unlock (mux_adl);
1633 }
1634 #endif // HAVE_HWMON
1635 }
1636
1637 static void status_benchmark ()
1638 {
1639 if (data.devices_status == STATUS_INIT) return;
1640 if (data.devices_status == STATUS_STARTING) return;
1641
1642 if (data.words_cnt == 0) return;
1643
1644 u64 speed_cnt[DEVICES_MAX] = { 0 };
1645 float speed_ms[DEVICES_MAX] = { 0 };
1646
1647 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1648 {
1649 hc_device_param_t *device_param = &data.devices_param[device_id];
1650
1651 if (device_param->skipped) continue;
1652
1653 speed_cnt[device_id] = 0;
1654 speed_ms[device_id] = 0;
1655
1656 for (int i = 0; i < SPEED_CACHE; i++)
1657 {
1658 speed_cnt[device_id] += device_param->speed_cnt[i];
1659 speed_ms[device_id] += device_param->speed_ms[i];
1660 }
1661
1662 speed_cnt[device_id] /= SPEED_CACHE;
1663 speed_ms[device_id] /= SPEED_CACHE;
1664 }
1665
1666 float hashes_all_ms = 0;
1667
1668 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1669
1670 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1671 {
1672 hc_device_param_t *device_param = &data.devices_param[device_id];
1673
1674 if (device_param->skipped) continue;
1675
1676 hashes_dev_ms[device_id] = 0;
1677
1678 if (speed_ms[device_id])
1679 {
1680 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1681
1682 hashes_all_ms += hashes_dev_ms[device_id];
1683 }
1684 }
1685
1686 /**
1687 * exec time
1688 */
1689
1690 double exec_all_ms[DEVICES_MAX] = { 0 };
1691
1692 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1693 {
1694 hc_device_param_t *device_param = &data.devices_param[device_id];
1695
1696 if (device_param->skipped) continue;
1697
1698 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1699
1700 exec_all_ms[device_id] = exec_ms_avg;
1701 }
1702
1703 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1704 {
1705 hc_device_param_t *device_param = &data.devices_param[device_id];
1706
1707 if (device_param->skipped) continue;
1708
1709 char display_dev_cur[16] = { 0 };
1710
1711 strncpy (display_dev_cur, "0.00", 4);
1712
1713 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1714
1715 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1716 }
1717
1718 char display_all_cur[16] = { 0 };
1719
1720 strncpy (display_all_cur, "0.00", 4);
1721
1722 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1723
1724 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1725 }
1726
1727 /**
1728 * oclHashcat -only- functions
1729 */
1730
1731 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1732 {
1733 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1734 {
1735 if (attack_kern == ATTACK_KERN_STRAIGHT)
1736 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1737 else if (attack_kern == ATTACK_KERN_COMBI)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_BF)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1741 }
1742 else
1743 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1744 }
1745
1746 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1747 {
1748 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1749 {
1750 if (attack_kern == ATTACK_KERN_STRAIGHT)
1751 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1752 else if (attack_kern == ATTACK_KERN_COMBI)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_BF)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 }
1757 else
1758 {
1759 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1760 }
1761 }
1762
1763 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1764 {
1765 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1766 {
1767 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1768 }
1769 else
1770 {
1771 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1772 }
1773 }
1774
1775 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1776 {
1777 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1778 {
1779 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1788 {
1789 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1790 }
1791
1792 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1793 {
1794 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1795 }
1796
1797 static uint convert_from_hex (char *line_buf, const uint line_len)
1798 {
1799 if (line_len & 1) return (line_len); // not in hex
1800
1801 if (data.hex_wordlist == 1)
1802 {
1803 uint i;
1804 uint j;
1805
1806 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1807 {
1808 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1809 }
1810
1811 memset (line_buf + i, 0, line_len - i);
1812
1813 return (i);
1814 }
1815 else if (line_len >= 6) // $HEX[] = 6
1816 {
1817 if (line_buf[0] != '$') return (line_len);
1818 if (line_buf[1] != 'H') return (line_len);
1819 if (line_buf[2] != 'E') return (line_len);
1820 if (line_buf[3] != 'X') return (line_len);
1821 if (line_buf[4] != '[') return (line_len);
1822 if (line_buf[line_len - 1] != ']') return (line_len);
1823
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836
1837 return (line_len);
1838 }
1839
1840 static void clear_prompt ()
1841 {
1842 fputc ('\r', stdout);
1843
1844 for (size_t i = 0; i < strlen (PROMPT); i++)
1845 {
1846 fputc (' ', stdout);
1847 }
1848
1849 fputc ('\r', stdout);
1850
1851 fflush (stdout);
1852 }
1853
1854 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1855 {
1856 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1857 }
1858
1859 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1860 {
1861 char *outfile = data.outfile;
1862 uint quiet = data.quiet;
1863 FILE *pot_fp = data.pot_fp;
1864 uint loopback = data.loopback;
1865 uint debug_mode = data.debug_mode;
1866 char *debug_file = data.debug_file;
1867
1868 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1869 int debug_rule_len = 0; // -1 error
1870 uint debug_plain_len = 0;
1871
1872 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1873
1874 // hash
1875
1876 char out_buf[4096] = { 0 };
1877
1878 ascii_digest (out_buf, salt_pos, digest_pos);
1879
1880 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1881
1882 // plain
1883
1884 plain_t plain;
1885
1886 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1887
1888 uint gidvid = plain.gidvid;
1889 uint il_pos = plain.il_pos;
1890
1891 u64 crackpos = device_param->words_off;
1892
1893 uint plain_buf[16] = { 0 };
1894
1895 u8 *plain_ptr = (u8 *) plain_buf;
1896 unsigned int plain_len = 0;
1897
1898 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1899 {
1900 u64 gidd = gidvid;
1901 u64 gidm = 0;
1902
1903 pw_t pw;
1904
1905 gidd_to_pw_t (device_param, gidd, &pw);
1906
1907 for (int i = 0, j = gidm; i < 16; i++, j++)
1908 {
1909 plain_buf[i] = pw.i[j];
1910 }
1911
1912 plain_len = pw.pw_len;
1913
1914 const uint off = device_param->innerloop_pos + il_pos;
1915
1916 if (debug_mode > 0)
1917 {
1918 debug_rule_len = 0;
1919
1920 // save rule
1921 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1922 {
1923 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1924
1925 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1926 }
1927
1928 // save plain
1929 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1930 {
1931 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1932
1933 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1934
1935 debug_plain_len = plain_len;
1936 }
1937 }
1938
1939 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1940
1941 crackpos += gidvid;
1942 crackpos *= data.kernel_rules_cnt;
1943 crackpos += device_param->innerloop_pos + il_pos;
1944
1945 if (plain_len > data.pw_max) plain_len = data.pw_max;
1946 }
1947 else if (data.attack_mode == ATTACK_MODE_COMBI)
1948 {
1949 u64 gidd = gidvid;
1950 u64 gidm = 0;
1951
1952 pw_t pw;
1953
1954 gidd_to_pw_t (device_param, gidd, &pw);
1955
1956 for (int i = 0, j = gidm; i < 16; i++, j++)
1957 {
1958 plain_buf[i] = pw.i[j];
1959 }
1960
1961 plain_len = pw.pw_len;
1962
1963 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1964 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1965
1966 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1967 {
1968 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1969 }
1970 else
1971 {
1972 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1973
1974 memcpy (plain_ptr, comb_buf, comb_len);
1975 }
1976
1977 plain_len += comb_len;
1978
1979 crackpos += gidvid;
1980 crackpos *= data.combs_cnt;
1981 crackpos += device_param->innerloop_pos + il_pos;
1982
1983 if (data.pw_max != PW_DICTMAX1)
1984 {
1985 if (plain_len > data.pw_max) plain_len = data.pw_max;
1986 }
1987 }
1988 else if (data.attack_mode == ATTACK_MODE_BF)
1989 {
1990 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1991 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1992
1993 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1994 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1995
1996 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1997 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1998
1999 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2000 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2001
2002 plain_len = data.css_cnt;
2003
2004 crackpos += gidvid;
2005 crackpos *= data.bfs_cnt;
2006 crackpos += device_param->innerloop_pos + il_pos;
2007 }
2008 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2009 {
2010 u64 gidd = gidvid;
2011 u64 gidm = 0;
2012
2013 pw_t pw;
2014
2015 gidd_to_pw_t (device_param, gidd, &pw);
2016
2017 for (int i = 0, j = gidm; i < 16; i++, j++)
2018 {
2019 plain_buf[i] = pw.i[j];
2020 }
2021
2022 plain_len = pw.pw_len;
2023
2024 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2025
2026 uint start = 0;
2027 uint stop = device_param->kernel_params_mp_buf32[4];
2028
2029 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2030
2031 plain_len += start + stop;
2032
2033 crackpos += gidvid;
2034 crackpos *= data.combs_cnt;
2035 crackpos += device_param->innerloop_pos + il_pos;
2036
2037 if (data.pw_max != PW_DICTMAX1)
2038 {
2039 if (plain_len > data.pw_max) plain_len = data.pw_max;
2040 }
2041 }
2042 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2043 {
2044 u64 gidd = gidvid;
2045 u64 gidm = 0;
2046
2047 pw_t pw;
2048
2049 gidd_to_pw_t (device_param, gidd, &pw);
2050
2051 for (int i = 0, j = gidm; i < 16; i++, j++)
2052 {
2053 plain_buf[i] = pw.i[j];
2054 }
2055
2056 plain_len = pw.pw_len;
2057
2058 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2059
2060 uint start = 0;
2061 uint stop = device_param->kernel_params_mp_buf32[4];
2062
2063 memmove (plain_ptr + stop, plain_ptr, plain_len);
2064
2065 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2066
2067 plain_len += start + stop;
2068
2069 crackpos += gidvid;
2070 crackpos *= data.combs_cnt;
2071 crackpos += device_param->innerloop_pos + il_pos;
2072
2073 if (data.pw_max != PW_DICTMAX1)
2074 {
2075 if (plain_len > data.pw_max) plain_len = data.pw_max;
2076 }
2077 }
2078
2079 if (data.attack_mode == ATTACK_MODE_BF)
2080 {
2081 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2082 {
2083 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2084 {
2085 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2086 {
2087 plain_len = plain_len - data.salts_buf[0].salt_len;
2088 }
2089 }
2090
2091 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2092 {
2093 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2094 {
2095 plain_ptr[j] = plain_ptr[i];
2096 }
2097
2098 plain_len = plain_len / 2;
2099 }
2100 }
2101 }
2102
2103 // if enabled, update also the potfile
2104
2105 if (pot_fp)
2106 {
2107 lock_file (pot_fp);
2108
2109 fprintf (pot_fp, "%s:", out_buf);
2110
2111 format_plain (pot_fp, plain_ptr, plain_len, 1);
2112
2113 fputc ('\n', pot_fp);
2114
2115 fflush (pot_fp);
2116
2117 unlock_file (pot_fp);
2118 }
2119
2120 // outfile
2121
2122 FILE *out_fp = NULL;
2123
2124 if (outfile != NULL)
2125 {
2126 if ((out_fp = fopen (outfile, "ab")) == NULL)
2127 {
2128 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2129
2130 out_fp = stdout;
2131 }
2132 lock_file (out_fp);
2133 }
2134 else
2135 {
2136 out_fp = stdout;
2137
2138 if (quiet == 0) clear_prompt ();
2139 }
2140
2141 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2142
2143 if (outfile != NULL)
2144 {
2145 if (out_fp != stdout)
2146 {
2147 fclose (out_fp);
2148 }
2149 }
2150 else
2151 {
2152 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2153 {
2154 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2155 {
2156 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2157 if (quiet == 0) fflush (stdout);
2158 }
2159 }
2160 }
2161
2162 // loopback
2163
2164 if (loopback)
2165 {
2166 char *loopback_file = data.loopback_file;
2167
2168 FILE *fb_fp = NULL;
2169
2170 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2171 {
2172 lock_file (fb_fp);
2173
2174 format_plain (fb_fp, plain_ptr, plain_len, 1);
2175
2176 fputc ('\n', fb_fp);
2177
2178 fclose (fb_fp);
2179 }
2180 }
2181
2182 // (rule) debug mode
2183
2184 // the next check implies that:
2185 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2186 // - debug_mode > 0
2187
2188 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2189 {
2190 if (debug_rule_len < 0) debug_rule_len = 0;
2191
2192 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2193
2194 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2195
2196 if ((quiet == 0) && (debug_file == NULL))
2197 {
2198 fprintf (stdout, "%s", PROMPT);
2199 fflush (stdout);
2200 }
2201 }
2202 }
2203
2204 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2205 {
2206 salt_t *salt_buf = &data.salts_buf[salt_pos];
2207
2208 int found = 0;
2209
2210 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2211
2212 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2213
2214 if (found == 1)
2215 {
2216 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2217
2218 log_info_nn ("");
2219
2220 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2221
2222 uint cpt_cracked = 0;
2223
2224 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2225 {
2226 uint idx = salt_buf->digests_offset + digest_pos;
2227
2228 if (data.digests_shown_tmp[idx] == 0) continue;
2229
2230 if (data.digests_shown[idx] == 1) continue;
2231
2232 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2233 {
2234 data.digests_shown[idx] = 1;
2235
2236 data.digests_done++;
2237
2238 cpt_cracked++;
2239
2240 salt_buf->digests_done++;
2241
2242 if (salt_buf->digests_done == salt_buf->digests_cnt)
2243 {
2244 data.salts_shown[salt_pos] = 1;
2245
2246 data.salts_done++;
2247 }
2248 }
2249
2250 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2251
2252 check_hash (device_param, salt_pos, digest_pos);
2253 }
2254
2255 if (cpt_cracked > 0)
2256 {
2257 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2258 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2259
2260 data.cpt_pos++;
2261
2262 data.cpt_total += cpt_cracked;
2263
2264 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2265 }
2266
2267 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2268 {
2269 // we need to reset cracked state on the device
2270 // otherwise host thinks again and again the hash was cracked
2271 // and returns invalid password each time
2272
2273 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2274
2275 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2276 }
2277
2278 memset (device_param->result, 0, device_param->size_results);
2279
2280 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2281 }
2282 }
2283
2284 static void save_hash ()
2285 {
2286 char *hashfile = data.hashfile;
2287
2288 char new_hashfile[256] = { 0 };
2289 char old_hashfile[256] = { 0 };
2290
2291 snprintf (new_hashfile, 255, "%s.new", hashfile);
2292 snprintf (old_hashfile, 255, "%s.old", hashfile);
2293
2294 unlink (new_hashfile);
2295
2296 char separator = data.separator;
2297
2298 FILE *fp = fopen (new_hashfile, "wb");
2299
2300 if (fp == NULL)
2301 {
2302 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2303
2304 exit (-1);
2305 }
2306
2307 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2308 {
2309 if (data.salts_shown[salt_pos] == 1) continue;
2310
2311 salt_t *salt_buf = &data.salts_buf[salt_pos];
2312
2313 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2314 {
2315 uint idx = salt_buf->digests_offset + digest_pos;
2316
2317 if (data.digests_shown[idx] == 1) continue;
2318
2319 if (data.hash_mode != 2500)
2320 {
2321 char out_buf[4096] = { 0 };
2322
2323 if (data.username == 1)
2324 {
2325 user_t *user = data.hash_info[idx]->user;
2326
2327 uint i;
2328
2329 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2330
2331 fputc (separator, fp);
2332 }
2333
2334 ascii_digest (out_buf, salt_pos, digest_pos);
2335
2336 fputs (out_buf, fp);
2337
2338 log_out (fp, "");
2339 }
2340 else
2341 {
2342 hccap_t hccap;
2343
2344 to_hccap_t (&hccap, salt_pos, digest_pos);
2345
2346 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2347 }
2348 }
2349 }
2350
2351 fflush (fp);
2352
2353 fclose (fp);
2354
2355 unlink (old_hashfile);
2356
2357 if (rename (hashfile, old_hashfile) != 0)
2358 {
2359 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2360
2361 exit (-1);
2362 }
2363
2364 unlink (hashfile);
2365
2366 if (rename (new_hashfile, hashfile) != 0)
2367 {
2368 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2369
2370 exit (-1);
2371 }
2372
2373 unlink (old_hashfile);
2374 }
2375
2376 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2377 {
2378 // function called only in case kernel_power_all > words_left
2379
2380 float kernel_power_div = (float) (total_left) / kernel_power_all;
2381
2382 kernel_power_div += kernel_power_div / 100;
2383
2384 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2385
2386 while (kernel_power_new < total_left)
2387 {
2388 kernel_power_div += kernel_power_div / 100;
2389
2390 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2391 }
2392
2393 if (data.quiet == 0)
2394 {
2395 clear_prompt ();
2396
2397 log_info ("");
2398
2399 log_info ("INFO: approaching final keyspace, workload adjusted");
2400
2401 log_info ("");
2402
2403 fprintf (stdout, "%s", PROMPT);
2404
2405 fflush (stdout);
2406 }
2407
2408 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2409
2410 return kernel_power_div;
2411 }
2412
2413 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2414 {
2415 uint num_elements = num;
2416
2417 device_param->kernel_params_buf32[30] = data.combs_mode;
2418 device_param->kernel_params_buf32[31] = num;
2419
2420 uint kernel_threads = device_param->kernel_threads;
2421
2422 while (num_elements % kernel_threads) num_elements++;
2423
2424 cl_kernel kernel = NULL;
2425
2426 switch (kern_run)
2427 {
2428 case KERN_RUN_1: kernel = device_param->kernel1; break;
2429 case KERN_RUN_12: kernel = device_param->kernel12; break;
2430 case KERN_RUN_2: kernel = device_param->kernel2; break;
2431 case KERN_RUN_23: kernel = device_param->kernel23; break;
2432 case KERN_RUN_3: kernel = device_param->kernel3; break;
2433 }
2434
2435 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2436 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2437 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2438 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2439 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2440 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2441 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2442 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2443 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2444 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2445 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2446
2447 hc_timer_t timer;
2448
2449 hc_timer_set (&timer);
2450
2451 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2452 {
2453 const size_t global_work_size[3] = { num_elements, 32, 1 };
2454 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2455
2456 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2457 }
2458 else
2459 {
2460 size_t workgroup_size = 0;
2461
2462 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2463
2464 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2465
2466 const size_t global_work_size[3] = { num_elements, 1, 1 };
2467 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2468
2469 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2470 }
2471
2472 hc_clFlush (data.ocl, device_param->command_queue);
2473
2474 hc_clFinish (data.ocl, device_param->command_queue);
2475
2476 if (event_update)
2477 {
2478 float exec_time;
2479
2480 hc_timer_get (timer, exec_time);
2481
2482 uint exec_pos = device_param->exec_pos;
2483
2484 device_param->exec_ms[exec_pos] = exec_time;
2485
2486 exec_pos++;
2487
2488 if (exec_pos == EXEC_CACHE)
2489 {
2490 exec_pos = 0;
2491 }
2492
2493 device_param->exec_pos = exec_pos;
2494 }
2495 }
2496
2497 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2498 {
2499 uint num_elements = num;
2500
2501 switch (kern_run)
2502 {
2503 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2504 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2505 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2506 }
2507
2508 // causes problems with special threads like in bcrypt
2509 // const uint kernel_threads = device_param->kernel_threads;
2510
2511 uint kernel_threads = KERNEL_THREADS;
2512
2513 while (num_elements % kernel_threads) num_elements++;
2514
2515 cl_kernel kernel = NULL;
2516
2517 switch (kern_run)
2518 {
2519 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2520 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2521 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2522 }
2523
2524 switch (kern_run)
2525 {
2526 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2527 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2528 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2529 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2530 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2531 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2532 break;
2533 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2534 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2535 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2536 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2537 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2538 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2539 break;
2540 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2541 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2542 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2543 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2544 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2545 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2546 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2547 break;
2548 }
2549
2550 size_t workgroup_size = 0;
2551 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2552 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2553
2554 const size_t global_work_size[3] = { num_elements, 1, 1 };
2555 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2556
2557 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2558
2559 hc_clFlush (data.ocl, device_param->command_queue);
2560
2561 hc_clFinish (data.ocl, device_param->command_queue);
2562 }
2563
2564 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2565 {
2566 uint num_elements = num;
2567
2568 uint kernel_threads = device_param->kernel_threads;
2569
2570 while (num_elements % kernel_threads) num_elements++;
2571
2572 cl_kernel kernel = device_param->kernel_tb;
2573
2574 size_t workgroup_size = 0;
2575 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2576 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2577
2578 const size_t global_work_size[3] = { num_elements, 1, 1 };
2579 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2580
2581 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2582
2583 hc_clFlush (data.ocl, device_param->command_queue);
2584
2585 hc_clFinish (data.ocl, device_param->command_queue);
2586 }
2587
2588 static void run_kernel_tm (hc_device_param_t *device_param)
2589 {
2590 const uint num_elements = 1024; // fixed
2591
2592 uint kernel_threads = 32;
2593
2594 cl_kernel kernel = device_param->kernel_tm;
2595
2596 size_t workgroup_size = 0;
2597 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2598 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2599
2600 const size_t global_work_size[3] = { num_elements, 1, 1 };
2601 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2602
2603 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2604
2605 hc_clFlush (data.ocl, device_param->command_queue);
2606
2607 hc_clFinish (data.ocl, device_param->command_queue);
2608 }
2609
2610 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2611 {
2612 uint num_elements = num;
2613
2614 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2615 device_param->kernel_params_amp_buf32[6] = num_elements;
2616
2617 // causes problems with special threads like in bcrypt
2618 // const uint kernel_threads = device_param->kernel_threads;
2619
2620 uint kernel_threads = KERNEL_THREADS;
2621
2622 while (num_elements % kernel_threads) num_elements++;
2623
2624 cl_kernel kernel = device_param->kernel_amp;
2625
2626 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2627 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2628
2629 size_t workgroup_size = 0;
2630 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2631 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2632
2633 const size_t global_work_size[3] = { num_elements, 1, 1 };
2634 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2635
2636 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2637
2638 hc_clFlush (data.ocl, device_param->command_queue);
2639
2640 hc_clFinish (data.ocl, device_param->command_queue);
2641 }
2642
2643 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2644 {
2645 int rc = -1;
2646
2647 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2648 {
2649 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2650
2651 const cl_uchar zero = 0;
2652
2653 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2654 }
2655
2656 if (rc != 0)
2657 {
2658 // NOTE: clEnqueueFillBuffer () always fails with -59
2659 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2660 // How's that possible, OpenCL 1.2 support is advertised??
2661 // We need to workaround...
2662
2663 #define FILLSZ 0x100000
2664
2665 char *tmp = (char *) mymalloc (FILLSZ);
2666
2667 for (uint i = 0; i < size; i += FILLSZ)
2668 {
2669 const int left = size - i;
2670
2671 const int fillsz = MIN (FILLSZ, left);
2672
2673 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2674 }
2675
2676 myfree (tmp);
2677 }
2678 }
2679
2680 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2681 {
2682 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2683 {
2684 if (attack_mode == ATTACK_MODE_BF)
2685 {
2686 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2687 {
2688 const uint size_tm = 32 * sizeof (bs_word_t);
2689
2690 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2691
2692 run_kernel_tm (device_param);
2693
2694 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2695 }
2696 }
2697
2698 if (highest_pw_len < 16)
2699 {
2700 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2701 }
2702 else if (highest_pw_len < 32)
2703 {
2704 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2705 }
2706 else
2707 {
2708 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2709 }
2710 }
2711 else
2712 {
2713 run_kernel_amp (device_param, pws_cnt);
2714
2715 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2716
2717 if (opts_type & OPTS_TYPE_HOOK12)
2718 {
2719 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2720 }
2721
2722 uint iter = salt_buf->salt_iter;
2723
2724 uint loop_step = device_param->kernel_loops;
2725
2726 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2727 {
2728 uint loop_left = iter - loop_pos;
2729
2730 loop_left = MIN (loop_left, loop_step);
2731
2732 device_param->kernel_params_buf32[25] = loop_pos;
2733 device_param->kernel_params_buf32[26] = loop_left;
2734
2735 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2736
2737 if (data.devices_status == STATUS_CRACKED) break;
2738 if (data.devices_status == STATUS_ABORTED) break;
2739 if (data.devices_status == STATUS_QUIT) break;
2740 }
2741
2742 if (opts_type & OPTS_TYPE_HOOK23)
2743 {
2744 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2745
2746 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2747
2748 // do something with data
2749
2750 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2751 }
2752
2753 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2754 }
2755 }
2756
2757 static int run_rule_engine (const int rule_len, const char *rule_buf)
2758 {
2759 if (rule_len == 0)
2760 {
2761 return 0;
2762 }
2763 else if (rule_len == 1)
2764 {
2765 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2766 }
2767
2768 return 1;
2769 }
2770
2771 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2772 {
2773 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2774 {
2775 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2776 }
2777 else if (data.attack_kern == ATTACK_KERN_COMBI)
2778 {
2779 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2780 {
2781 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2782 {
2783 for (u32 i = 0; i < pws_cnt; i++)
2784 {
2785 const u32 pw_len = device_param->pws_buf[i].pw_len;
2786
2787 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2788
2789 ptr[pw_len] = 0x01;
2790 }
2791 }
2792 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2793 {
2794 for (u32 i = 0; i < pws_cnt; i++)
2795 {
2796 const u32 pw_len = device_param->pws_buf[i].pw_len;
2797
2798 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2799
2800 ptr[pw_len] = 0x80;
2801 }
2802 }
2803 }
2804
2805 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);
2806 }
2807 else if (data.attack_kern == ATTACK_KERN_BF)
2808 {
2809 const u64 off = device_param->words_off;
2810
2811 device_param->kernel_params_mp_l_buf64[3] = off;
2812
2813 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2814 }
2815 }
2816
2817 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2818 {
2819 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2820
2821 device_param->kernel_params_buf32[26] = kernel_loops;
2822 device_param->kernel_params_buf32[27] = kernel_loops;
2823
2824 // init some fake words
2825
2826 if (data.attack_kern == ATTACK_KERN_BF)
2827 {
2828 run_kernel_mp (KERN_RUN_MP_L, device_param, kernel_power);
2829 run_kernel_mp (KERN_RUN_MP_R, device_param, kernel_loops);
2830 }
2831 else
2832 {
2833 for (u32 i = 0; i < kernel_power; i++)
2834 {
2835 device_param->pws_buf[i].pw_len = i & 7;
2836 }
2837
2838 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);
2839
2840 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2841 {
2842 run_kernel_amp (device_param, kernel_power);
2843 }
2844 }
2845
2846 // caching run
2847
2848 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2849 {
2850 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2851 }
2852 else
2853 {
2854 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2855 }
2856
2857 // now user repeats
2858
2859 for (int i = 0; i < repeat; i++)
2860 {
2861 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2862 {
2863 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2864 }
2865 else
2866 {
2867 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2868 }
2869 }
2870
2871 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2872
2873 // reset fake words
2874
2875 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2876
2877 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);
2878 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);
2879
2880 return exec_ms_prev;
2881 }
2882
2883 static void autotune (hc_device_param_t *device_param)
2884 {
2885 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2886
2887 const u32 kernel_accel_min = device_param->kernel_accel_min;
2888 const u32 kernel_accel_max = device_param->kernel_accel_max;
2889
2890 const u32 kernel_loops_min = device_param->kernel_loops_min;
2891 const u32 kernel_loops_max = device_param->kernel_loops_max;
2892
2893 u32 kernel_accel = kernel_accel_min;
2894 u32 kernel_loops = kernel_loops_min;
2895
2896 // steps
2897
2898 #define STEPS_CNT 10
2899
2900 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2901 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2902
2903 u32 steps_accel[STEPS_ACCEL_CNT];
2904 u32 steps_loops[STEPS_LOOPS_CNT];
2905
2906 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2907 {
2908 steps_accel[i] = 1 << i;
2909 }
2910
2911 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2912 {
2913 steps_loops[i] = 1 << i;
2914 }
2915
2916 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2917 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2918
2919 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2920 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2921
2922 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2923 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2924
2925 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2926
2927 u32 kernel_loops_tmp;
2928
2929 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2930 {
2931 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2932
2933 if (exec_ms < target_ms) break;
2934 }
2935
2936 // kernel-accel
2937
2938 if (kernel_accel_min < kernel_accel_max)
2939 {
2940 double e_best = 0;
2941
2942 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2943 {
2944 const u32 kernel_accel_try = steps_accel[i];
2945
2946 if (kernel_accel_try < kernel_accel_min) continue;
2947 if (kernel_accel_try > kernel_accel_max) break;
2948
2949 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2950
2951 if (exec_ms > target_ms) break;
2952
2953 const double e = kernel_accel_try / exec_ms;
2954
2955 if (e > e_best)
2956 {
2957 kernel_accel = kernel_accel_try;
2958
2959 e_best = e;
2960 }
2961 }
2962 }
2963
2964 // kernel-loops final
2965
2966 if (kernel_loops_min < kernel_loops_max)
2967 {
2968 double e_best = 0;
2969
2970 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2971 {
2972 const u32 kernel_loops_try = steps_loops[i];
2973
2974 if (kernel_loops_try < kernel_loops_min) continue;
2975 if (kernel_loops_try > kernel_loops_max) break;
2976
2977 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2978
2979 if (exec_ms > target_ms) break;
2980
2981 const double e = kernel_loops_try / exec_ms;
2982
2983 if (e > e_best)
2984 {
2985 kernel_loops = kernel_loops_try;
2986
2987 e_best = e;
2988 }
2989 }
2990 }
2991
2992 // final balance
2993
2994 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops, 1);
2995
2996 u32 kernel_accel_best = kernel_accel;
2997 u32 kernel_loops_best = kernel_loops;
2998
2999 u32 exec_best = exec_ms;
3000
3001 // reset
3002
3003 if (kernel_accel_min < kernel_accel_max)
3004 {
3005 u32 kernel_accel_try = kernel_accel;
3006 u32 kernel_loops_try = kernel_loops;
3007
3008 for (int i = 0; i < 2; i++)
3009 {
3010 kernel_accel_try >>= 1;
3011 kernel_loops_try <<= 1;
3012
3013 if (kernel_accel_try < kernel_accel_min) break;
3014 if (kernel_loops_try > kernel_loops_max) break;
3015
3016 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3017
3018 if (exec_ms < exec_best)
3019 {
3020 kernel_accel_best = kernel_accel_try;
3021 kernel_loops_best = kernel_loops_try;
3022
3023 exec_best = exec_ms;
3024 }
3025 }
3026
3027 kernel_accel = kernel_accel_best;
3028 kernel_loops = kernel_loops_best;
3029 }
3030
3031 // reset
3032
3033
3034 if (kernel_loops_min < kernel_loops_max)
3035 {
3036 u32 kernel_accel_try = kernel_accel;
3037 u32 kernel_loops_try = kernel_loops;
3038
3039 for (int i = 0; i < 2; i++)
3040 {
3041 kernel_accel_try <<= 1;
3042 kernel_loops_try >>= 1;
3043
3044 if (kernel_accel_try > kernel_accel_max) break;
3045 if (kernel_loops_try < kernel_loops_min) break;
3046
3047 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3048
3049 if (exec_ms < exec_best)
3050 {
3051 kernel_accel_best = kernel_accel_try;
3052 kernel_loops_best = kernel_loops_try;
3053
3054 exec_best = exec_ms;
3055 }
3056 }
3057
3058 kernel_accel = kernel_accel_best;
3059 kernel_loops = kernel_loops_best;
3060 }
3061
3062 // reset timer
3063
3064 device_param->exec_pos = 0;
3065
3066 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3067
3068 // store
3069
3070 device_param->kernel_loops = kernel_loops;
3071 device_param->kernel_accel = kernel_accel;
3072
3073 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3074
3075 device_param->kernel_power = kernel_power;
3076
3077 if (data.quiet == 0) log_info ("Device #%u: autotuned kernel-accel to %u", device_param->device_id + 1, kernel_accel);
3078 if (data.quiet == 0) log_info ("Device #%u: autotuned kernel-loops to %u", device_param->device_id + 1, kernel_loops);
3079 if (data.quiet == 0) log_info ("");
3080 }
3081
3082 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3083 {
3084 // init speed timer
3085
3086 uint speed_pos = device_param->speed_pos;
3087
3088 #ifdef _POSIX
3089 if (device_param->timer_speed.tv_sec == 0)
3090 {
3091 hc_timer_set (&device_param->timer_speed);
3092 }
3093 #endif
3094
3095 #ifdef _WIN
3096 if (device_param->timer_speed.QuadPart == 0)
3097 {
3098 hc_timer_set (&device_param->timer_speed);
3099 }
3100 #endif
3101
3102 // find higest password length, this is for optimization stuff
3103
3104 uint highest_pw_len = 0;
3105
3106 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3107 {
3108 }
3109 else if (data.attack_kern == ATTACK_KERN_COMBI)
3110 {
3111 }
3112 else if (data.attack_kern == ATTACK_KERN_BF)
3113 {
3114 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3115 + device_param->kernel_params_mp_l_buf32[5];
3116 }
3117
3118 // bitslice optimization stuff
3119
3120 if (data.attack_mode == ATTACK_MODE_BF)
3121 {
3122 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3123 {
3124 run_kernel_tb (device_param, pws_cnt);
3125 }
3126 }
3127
3128 // iteration type
3129
3130 uint innerloop_step = 0;
3131 uint innerloop_cnt = 0;
3132
3133 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3134 else innerloop_step = 1;
3135
3136 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3137 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3138 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3139
3140 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3141
3142 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3143 {
3144 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3145
3146 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3147
3148 if (data.devices_status == STATUS_CRACKED) break;
3149 if (data.devices_status == STATUS_ABORTED) break;
3150 if (data.devices_status == STATUS_QUIT) break;
3151 if (data.devices_status == STATUS_BYPASS) break;
3152
3153 if (data.salts_shown[salt_pos] == 1) continue;
3154
3155 salt_t *salt_buf = &data.salts_buf[salt_pos];
3156
3157 device_param->kernel_params_buf32[24] = salt_pos;
3158 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3159 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3160
3161 FILE *combs_fp = device_param->combs_fp;
3162
3163 if (data.attack_mode == ATTACK_MODE_COMBI)
3164 {
3165 rewind (combs_fp);
3166 }
3167
3168 // innerloops
3169
3170 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3171 {
3172 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3173
3174 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3175
3176 if (data.devices_status == STATUS_CRACKED) break;
3177 if (data.devices_status == STATUS_ABORTED) break;
3178 if (data.devices_status == STATUS_QUIT) break;
3179 if (data.devices_status == STATUS_BYPASS) break;
3180
3181 uint innerloop_left = innerloop_cnt - innerloop_pos;
3182
3183 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3184
3185 device_param->innerloop_pos = innerloop_pos;
3186 device_param->innerloop_left = innerloop_left;
3187
3188 device_param->kernel_params_buf32[27] = innerloop_left;
3189
3190 // i think we can get rid of this
3191 if (innerloop_left == 0)
3192 {
3193 puts ("bug, how should this happen????\n");
3194
3195 continue;
3196 }
3197
3198 // initialize amplifiers
3199
3200 if (data.attack_mode == ATTACK_MODE_COMBI)
3201 {
3202 char line_buf[BUFSIZ] = { 0 };
3203
3204 uint i = 0;
3205
3206 while (i < innerloop_left)
3207 {
3208 if (feof (combs_fp)) break;
3209
3210 int line_len = fgetl (combs_fp, line_buf);
3211
3212 if (line_len >= PW_MAX1) continue;
3213
3214 line_len = convert_from_hex (line_buf, line_len);
3215
3216 char *line_buf_new = line_buf;
3217
3218 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3219 {
3220 char rule_buf_out[BLOCK_SIZE] = { 0 };
3221
3222 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3223
3224 if (rule_len_out < 0)
3225 {
3226 data.words_progress_rejected[salt_pos] += pws_cnt;
3227
3228 continue;
3229 }
3230
3231 line_len = rule_len_out;
3232
3233 line_buf_new = rule_buf_out;
3234 }
3235
3236 line_len = MIN (line_len, PW_DICTMAX);
3237
3238 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3239
3240 memcpy (ptr, line_buf_new, line_len);
3241
3242 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3243
3244 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3245 {
3246 uppercase (ptr, line_len);
3247 }
3248
3249 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3250 {
3251 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3252 {
3253 ptr[line_len] = 0x80;
3254 }
3255
3256 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3257 {
3258 ptr[line_len] = 0x01;
3259 }
3260 }
3261
3262 device_param->combs_buf[i].pw_len = line_len;
3263
3264 i++;
3265 }
3266
3267 for (uint j = i; j < innerloop_left; j++)
3268 {
3269 device_param->combs_buf[j].i[0] = 0;
3270 device_param->combs_buf[j].i[1] = 0;
3271 device_param->combs_buf[j].i[2] = 0;
3272 device_param->combs_buf[j].i[3] = 0;
3273 device_param->combs_buf[j].i[4] = 0;
3274 device_param->combs_buf[j].i[5] = 0;
3275 device_param->combs_buf[j].i[6] = 0;
3276 device_param->combs_buf[j].i[7] = 0;
3277
3278 device_param->combs_buf[j].pw_len = 0;
3279 }
3280
3281 innerloop_left = i;
3282 }
3283 else if (data.attack_mode == ATTACK_MODE_BF)
3284 {
3285 u64 off = innerloop_pos;
3286
3287 device_param->kernel_params_mp_r_buf64[3] = off;
3288
3289 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3290 }
3291 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3292 {
3293 u64 off = innerloop_pos;
3294
3295 device_param->kernel_params_mp_buf64[3] = off;
3296
3297 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3298 }
3299 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3300 {
3301 u64 off = innerloop_pos;
3302
3303 device_param->kernel_params_mp_buf64[3] = off;
3304
3305 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3306 }
3307
3308 // copy amplifiers
3309
3310 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3311 {
3312 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);
3313 }
3314 else if (data.attack_mode == ATTACK_MODE_COMBI)
3315 {
3316 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);
3317 }
3318 else if (data.attack_mode == ATTACK_MODE_BF)
3319 {
3320 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);
3321 }
3322 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3323 {
3324 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);
3325 }
3326 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3327 {
3328 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);
3329 }
3330
3331 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3332
3333 if (data.benchmark == 1)
3334 {
3335 for (u32 i = 0; i < data.benchmark_repeats; i++)
3336 {
3337 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3338 }
3339 }
3340
3341 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3342
3343 if (data.devices_status == STATUS_CRACKED) break;
3344 if (data.devices_status == STATUS_ABORTED) break;
3345 if (data.devices_status == STATUS_QUIT) break;
3346
3347 /**
3348 * result
3349 */
3350
3351 hc_thread_mutex_lock (mux_display);
3352
3353 check_cracked (device_param, salt_pos);
3354
3355 hc_thread_mutex_unlock (mux_display);
3356
3357 /**
3358 * progress
3359 */
3360
3361 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3362
3363 if (data.benchmark == 1)
3364 {
3365 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3366 }
3367
3368 hc_thread_mutex_lock (mux_counter);
3369
3370 data.words_progress_done[salt_pos] += perf_sum_all;
3371
3372 hc_thread_mutex_unlock (mux_counter);
3373
3374 /**
3375 * speed
3376 */
3377
3378 float speed_ms;
3379
3380 hc_timer_get (device_param->timer_speed, speed_ms);
3381
3382 hc_timer_set (&device_param->timer_speed);
3383
3384 hc_thread_mutex_lock (mux_display);
3385
3386 device_param->speed_cnt[speed_pos] = perf_sum_all;
3387
3388 device_param->speed_ms[speed_pos] = speed_ms;
3389
3390 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3391
3392 hc_thread_mutex_unlock (mux_display);
3393
3394 speed_pos++;
3395
3396 if (speed_pos == SPEED_CACHE)
3397 {
3398 speed_pos = 0;
3399 }
3400
3401 /**
3402 * benchmark
3403 */
3404
3405 if (data.benchmark == 1) break;
3406 }
3407 }
3408
3409 device_param->speed_pos = speed_pos;
3410 }
3411
3412 static void load_segment (wl_data_t *wl_data, FILE *fd)
3413 {
3414 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3415
3416 wl_data->pos = 0;
3417
3418 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3419
3420 wl_data->buf[wl_data->cnt] = 0;
3421
3422 if (wl_data->cnt == 0) return;
3423
3424 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3425
3426 while (!feof (fd))
3427 {
3428 if (wl_data->cnt == wl_data->avail)
3429 {
3430 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3431
3432 wl_data->avail += wl_data->incr;
3433 }
3434
3435 const int c = fgetc (fd);
3436
3437 if (c == EOF) break;
3438
3439 wl_data->buf[wl_data->cnt] = (char) c;
3440
3441 wl_data->cnt++;
3442
3443 if (c == '\n') break;
3444 }
3445
3446 // ensure stream ends with a newline
3447
3448 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3449 {
3450 wl_data->cnt++;
3451
3452 wl_data->buf[wl_data->cnt - 1] = '\n';
3453 }
3454
3455 return;
3456 }
3457
3458 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3459 {
3460 char *ptr = buf;
3461
3462 for (u32 i = 0; i < sz; i++, ptr++)
3463 {
3464 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3465
3466 if (i == 7)
3467 {
3468 *off = i;
3469 *len = i;
3470
3471 return;
3472 }
3473
3474 if (*ptr != '\n') continue;
3475
3476 *off = i + 1;
3477
3478 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3479
3480 *len = i;
3481
3482 return;
3483 }
3484
3485 *off = sz;
3486 *len = sz;
3487 }
3488
3489 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3490 {
3491 char *ptr = buf;
3492
3493 for (u32 i = 0; i < sz; i++, ptr++)
3494 {
3495 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3496
3497 if (*ptr != '\n') continue;
3498
3499 *off = i + 1;
3500
3501 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3502
3503 *len = i;
3504
3505 return;
3506 }
3507
3508 *off = sz;
3509 *len = sz;
3510 }
3511
3512 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3513 {
3514 char *ptr = buf;
3515
3516 for (u32 i = 0; i < sz; i++, ptr++)
3517 {
3518 if (*ptr != '\n') continue;
3519
3520 *off = i + 1;
3521
3522 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3523
3524 *len = i;
3525
3526 return;
3527 }
3528
3529 *off = sz;
3530 *len = sz;
3531 }
3532
3533 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3534 {
3535 while (wl_data->pos < wl_data->cnt)
3536 {
3537 uint off;
3538 uint len;
3539
3540 char *ptr = wl_data->buf + wl_data->pos;
3541
3542 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3543
3544 wl_data->pos += off;
3545
3546 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3547 {
3548 char rule_buf_out[BLOCK_SIZE] = { 0 };
3549
3550 int rule_len_out = -1;
3551
3552 if (len < BLOCK_SIZE)
3553 {
3554 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3555 }
3556
3557 if (rule_len_out < 0)
3558 {
3559 continue;
3560 }
3561
3562 if (rule_len_out > PW_MAX)
3563 {
3564 continue;
3565 }
3566 }
3567 else
3568 {
3569 if (len > PW_MAX)
3570 {
3571 continue;
3572 }
3573 }
3574
3575 *out_buf = ptr;
3576 *out_len = len;
3577
3578 return;
3579 }
3580
3581 if (feof (fd))
3582 {
3583 fprintf (stderr, "BUG feof()!!\n");
3584
3585 return;
3586 }
3587
3588 load_segment (wl_data, fd);
3589
3590 get_next_word (wl_data, fd, out_buf, out_len);
3591 }
3592
3593 #ifdef _POSIX
3594 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3595 #endif
3596
3597 #ifdef _WIN
3598 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3599 #endif
3600 {
3601 hc_signal (NULL);
3602
3603 dictstat_t d;
3604
3605 d.cnt = 0;
3606
3607 #ifdef _POSIX
3608 fstat (fileno (fd), &d.stat);
3609 #endif
3610
3611 #ifdef _WIN
3612 _fstat64 (fileno (fd), &d.stat);
3613 #endif
3614
3615 d.stat.st_mode = 0;
3616 d.stat.st_nlink = 0;
3617 d.stat.st_uid = 0;
3618 d.stat.st_gid = 0;
3619 d.stat.st_rdev = 0;
3620 d.stat.st_atime = 0;
3621
3622 #ifdef _POSIX
3623 d.stat.st_blksize = 0;
3624 d.stat.st_blocks = 0;
3625 #endif
3626
3627 if (d.stat.st_size == 0) return 0;
3628
3629 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3630
3631 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3632 {
3633 if (d_cache)
3634 {
3635 u64 cnt = d_cache->cnt;
3636
3637 u64 keyspace = cnt;
3638
3639 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3640 {
3641 keyspace *= data.kernel_rules_cnt;
3642 }
3643 else if (data.attack_kern == ATTACK_KERN_COMBI)
3644 {
3645 keyspace *= data.combs_cnt;
3646 }
3647
3648 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);
3649 if (data.quiet == 0) log_info ("");
3650
3651 hc_signal (sigHandler_default);
3652
3653 return (keyspace);
3654 }
3655 }
3656
3657 time_t now = 0;
3658 time_t prev = 0;
3659
3660 u64 comp = 0;
3661 u64 cnt = 0;
3662 u64 cnt2 = 0;
3663
3664 while (!feof (fd))
3665 {
3666 load_segment (wl_data, fd);
3667
3668 comp += wl_data->cnt;
3669
3670 u32 i = 0;
3671
3672 while (i < wl_data->cnt)
3673 {
3674 u32 len;
3675 u32 off;
3676
3677 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3678
3679 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3680 {
3681 char rule_buf_out[BLOCK_SIZE] = { 0 };
3682
3683 int rule_len_out = -1;
3684
3685 if (len < BLOCK_SIZE)
3686 {
3687 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3688 }
3689
3690 if (rule_len_out < 0)
3691 {
3692 len = PW_MAX1;
3693 }
3694 else
3695 {
3696 len = rule_len_out;
3697 }
3698 }
3699
3700 if (len < PW_MAX1)
3701 {
3702 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3703 {
3704 cnt += data.kernel_rules_cnt;
3705 }
3706 else if (data.attack_kern == ATTACK_KERN_COMBI)
3707 {
3708 cnt += data.combs_cnt;
3709 }
3710
3711 d.cnt++;
3712 }
3713
3714 i += off;
3715
3716 cnt2++;
3717 }
3718
3719 time (&now);
3720
3721 if ((now - prev) == 0) continue;
3722
3723 float percent = (float) comp / (float) d.stat.st_size;
3724
3725 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);
3726
3727 time (&prev);
3728 }
3729
3730 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);
3731 if (data.quiet == 0) log_info ("");
3732
3733 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3734
3735 hc_signal (sigHandler_default);
3736
3737 return (cnt);
3738 }
3739
3740 static void *thread_monitor (void *p)
3741 {
3742 uint runtime_check = 0;
3743 uint remove_check = 0;
3744 uint status_check = 0;
3745 uint restore_check = 0;
3746
3747 uint restore_left = data.restore_timer;
3748 uint remove_left = data.remove_timer;
3749 uint status_left = data.status_timer;
3750
3751 #ifdef HAVE_HWMON
3752 uint hwmon_check = 0;
3753
3754 // these variables are mainly used for fan control (AMD only)
3755
3756 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3757
3758 // temperature controller "loopback" values
3759
3760 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3761 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3762
3763 #ifdef HAVE_ADL
3764 int temp_threshold = 1; // degrees celcius
3765
3766 int fan_speed_min = 15; // in percentage
3767 int fan_speed_max = 100;
3768 #endif // HAVE_ADL
3769
3770 time_t last_temp_check_time;
3771 #endif // HAVE_HWMON
3772
3773 uint sleep_time = 1;
3774
3775 if (data.runtime)
3776 {
3777 runtime_check = 1;
3778 }
3779
3780 if (data.restore_timer)
3781 {
3782 restore_check = 1;
3783 }
3784
3785 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3786 {
3787 remove_check = 1;
3788 }
3789
3790 if (data.status == 1)
3791 {
3792 status_check = 1;
3793 }
3794
3795 #ifdef HAVE_HWMON
3796 if (data.gpu_temp_disable == 0)
3797 {
3798 time (&last_temp_check_time);
3799
3800 hwmon_check = 1;
3801 }
3802 #endif
3803
3804 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3805 {
3806 #ifdef HAVE_HWMON
3807 if (hwmon_check == 0)
3808 #endif
3809 return (p);
3810 }
3811
3812 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3813 {
3814 hc_sleep (sleep_time);
3815
3816 if (data.devices_status != STATUS_RUNNING) continue;
3817
3818 #ifdef HAVE_HWMON
3819 if (hwmon_check == 1)
3820 {
3821 hc_thread_mutex_lock (mux_adl);
3822
3823 time_t temp_check_time;
3824
3825 time (&temp_check_time);
3826
3827 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3828
3829 if (Ta == 0) Ta = 1;
3830
3831 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3832 {
3833 hc_device_param_t *device_param = &data.devices_param[device_id];
3834
3835 if (device_param->skipped) continue;
3836
3837 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3838
3839 const int temperature = hm_get_temperature_with_device_id (device_id);
3840
3841 if (temperature > (int) data.gpu_temp_abort)
3842 {
3843 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3844
3845 if (data.devices_status != STATUS_QUIT) myabort ();
3846
3847 break;
3848 }
3849
3850 #ifdef HAVE_ADL
3851 const int gpu_temp_retain = data.gpu_temp_retain;
3852
3853 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3854 {
3855 if (data.hm_device[device_id].fan_supported == 1)
3856 {
3857 int temp_cur = temperature;
3858
3859 int temp_diff_new = gpu_temp_retain - temp_cur;
3860
3861 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3862
3863 // calculate Ta value (time difference in seconds between the last check and this check)
3864
3865 last_temp_check_time = temp_check_time;
3866
3867 float Kp = 1.8;
3868 float Ki = 0.005;
3869 float Kd = 6;
3870
3871 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3872
3873 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);
3874
3875 if (abs (fan_diff_required) >= temp_threshold)
3876 {
3877 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3878
3879 int fan_speed_level = fan_speed_cur;
3880
3881 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3882
3883 int fan_speed_new = fan_speed_level - fan_diff_required;
3884
3885 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3886 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3887
3888 if (fan_speed_new != fan_speed_cur)
3889 {
3890 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3891 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3892
3893 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3894 {
3895 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3896
3897 fan_speed_chgd[device_id] = 1;
3898 }
3899
3900 temp_diff_old[device_id] = temp_diff_new;
3901 }
3902 }
3903 }
3904 }
3905 #endif // HAVE_ADL
3906 }
3907
3908 hc_thread_mutex_unlock (mux_adl);
3909 }
3910 #endif // HAVE_HWMON
3911
3912 if (restore_check == 1)
3913 {
3914 restore_left--;
3915
3916 if (restore_left == 0)
3917 {
3918 if (data.restore_disable == 0) cycle_restore ();
3919
3920 restore_left = data.restore_timer;
3921 }
3922 }
3923
3924 if ((runtime_check == 1) && (data.runtime_start > 0))
3925 {
3926 time_t runtime_cur;
3927
3928 time (&runtime_cur);
3929
3930 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3931
3932 if (runtime_left <= 0)
3933 {
3934 if (data.benchmark == 0)
3935 {
3936 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3937 }
3938
3939 if (data.devices_status != STATUS_QUIT) myabort ();
3940 }
3941 }
3942
3943 if (remove_check == 1)
3944 {
3945 remove_left--;
3946
3947 if (remove_left == 0)
3948 {
3949 if (data.digests_saved != data.digests_done)
3950 {
3951 data.digests_saved = data.digests_done;
3952
3953 save_hash ();
3954 }
3955
3956 remove_left = data.remove_timer;
3957 }
3958 }
3959
3960 if (status_check == 1)
3961 {
3962 status_left--;
3963
3964 if (status_left == 0)
3965 {
3966 hc_thread_mutex_lock (mux_display);
3967
3968 if (data.quiet == 0) clear_prompt ();
3969
3970 if (data.quiet == 0) log_info ("");
3971
3972 status_display ();
3973
3974 if (data.quiet == 0) log_info ("");
3975
3976 hc_thread_mutex_unlock (mux_display);
3977
3978 status_left = data.status_timer;
3979 }
3980 }
3981 }
3982
3983 #ifdef HAVE_HWMON
3984 myfree (fan_speed_chgd);
3985
3986 myfree (temp_diff_old);
3987 myfree (temp_diff_sum);
3988 #endif
3989
3990 p = NULL;
3991
3992 return (p);
3993 }
3994
3995 static void *thread_outfile_remove (void *p)
3996 {
3997 // some hash-dependent constants
3998 char *outfile_dir = data.outfile_check_directory;
3999 uint dgst_size = data.dgst_size;
4000 uint isSalted = data.isSalted;
4001 uint esalt_size = data.esalt_size;
4002 uint hash_mode = data.hash_mode;
4003
4004 uint outfile_check_timer = data.outfile_check_timer;
4005
4006 char separator = data.separator;
4007
4008 // some hash-dependent functions
4009 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4010 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4011
4012 // buffers
4013 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4014
4015 hash_buf.digest = mymalloc (dgst_size);
4016
4017 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4018
4019 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4020
4021 uint digest_buf[64] = { 0 };
4022
4023 outfile_data_t *out_info = NULL;
4024
4025 char **out_files = NULL;
4026
4027 time_t folder_mtime = 0;
4028
4029 int out_cnt = 0;
4030
4031 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4032
4033 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4034 {
4035 hc_sleep (1);
4036
4037 if (data.devices_status != STATUS_RUNNING) continue;
4038
4039 check_left--;
4040
4041 if (check_left == 0)
4042 {
4043 struct stat outfile_check_stat;
4044
4045 if (stat (outfile_dir, &outfile_check_stat) == 0)
4046 {
4047 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4048
4049 if (is_dir == 1)
4050 {
4051 if (outfile_check_stat.st_mtime > folder_mtime)
4052 {
4053 char **out_files_new = scan_directory (outfile_dir);
4054
4055 int out_cnt_new = count_dictionaries (out_files_new);
4056
4057 outfile_data_t *out_info_new = NULL;
4058
4059 if (out_cnt_new > 0)
4060 {
4061 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4062
4063 for (int i = 0; i < out_cnt_new; i++)
4064 {
4065 out_info_new[i].file_name = out_files_new[i];
4066
4067 // check if there are files that we have seen/checked before (and not changed)
4068
4069 for (int j = 0; j < out_cnt; j++)
4070 {
4071 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4072 {
4073 struct stat outfile_stat;
4074
4075 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4076 {
4077 if (outfile_stat.st_ctime == out_info[j].ctime)
4078 {
4079 out_info_new[i].ctime = out_info[j].ctime;
4080 out_info_new[i].seek = out_info[j].seek;
4081 }
4082 }
4083 }
4084 }
4085 }
4086 }
4087
4088 local_free (out_info);
4089 local_free (out_files);
4090
4091 out_files = out_files_new;
4092 out_cnt = out_cnt_new;
4093 out_info = out_info_new;
4094
4095 folder_mtime = outfile_check_stat.st_mtime;
4096 }
4097
4098 for (int j = 0; j < out_cnt; j++)
4099 {
4100 FILE *fp = fopen (out_info[j].file_name, "rb");
4101
4102 if (fp != NULL)
4103 {
4104 //hc_thread_mutex_lock (mux_display);
4105
4106 #ifdef _POSIX
4107 struct stat outfile_stat;
4108
4109 fstat (fileno (fp), &outfile_stat);
4110 #endif
4111
4112 #ifdef _WIN
4113 struct stat64 outfile_stat;
4114
4115 _fstat64 (fileno (fp), &outfile_stat);
4116 #endif
4117
4118 if (outfile_stat.st_ctime > out_info[j].ctime)
4119 {
4120 out_info[j].ctime = outfile_stat.st_ctime;
4121 out_info[j].seek = 0;
4122 }
4123
4124 fseek (fp, out_info[j].seek, SEEK_SET);
4125
4126 while (!feof (fp))
4127 {
4128 char line_buf[BUFSIZ] = { 0 };
4129
4130 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
4131
4132 if (ptr == NULL) break;
4133
4134 int line_len = strlen (line_buf);
4135
4136 if (line_len <= 0) continue;
4137
4138 int iter = MAX_CUT_TRIES;
4139
4140 for (uint i = line_len - 1; i && iter; i--, line_len--)
4141 {
4142 if (line_buf[i] != separator) continue;
4143
4144 int parser_status = PARSER_OK;
4145
4146 if ((hash_mode != 2500) && (hash_mode != 6800))
4147 {
4148 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4149 }
4150
4151 uint found = 0;
4152
4153 if (parser_status == PARSER_OK)
4154 {
4155 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4156 {
4157 if (data.salts_shown[salt_pos] == 1) continue;
4158
4159 salt_t *salt_buf = &data.salts_buf[salt_pos];
4160
4161 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4162 {
4163 uint idx = salt_buf->digests_offset + digest_pos;
4164
4165 if (data.digests_shown[idx] == 1) continue;
4166
4167 uint cracked = 0;
4168
4169 if (hash_mode == 6800)
4170 {
4171 if (i == salt_buf->salt_len)
4172 {
4173 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4174 }
4175 }
4176 else if (hash_mode == 2500)
4177 {
4178 // BSSID : MAC1 : MAC2 (:plain)
4179 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4180 {
4181 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4182
4183 if (!cracked) continue;
4184
4185 // now compare MAC1 and MAC2 too, since we have this additional info
4186 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4187 char *mac2_pos = mac1_pos + 12 + 1;
4188
4189 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4190 wpa_t *wpa = &wpas[salt_pos];
4191
4192 uint pke[25] = { 0 };
4193
4194 char *pke_ptr = (char *) pke;
4195
4196 for (uint i = 0; i < 25; i++)
4197 {
4198 pke[i] = byte_swap_32 (wpa->pke[i]);
4199 }
4200
4201 u8 mac1[6] = { 0 };
4202 u8 mac2[6] = { 0 };
4203
4204 memcpy (mac1, pke_ptr + 23, 6);
4205 memcpy (mac2, pke_ptr + 29, 6);
4206
4207 // compare hex string(s) vs binary MAC address(es)
4208
4209 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4210 {
4211 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4212 {
4213 cracked = 0;
4214 break;
4215 }
4216 }
4217
4218 // early skip ;)
4219 if (!cracked) continue;
4220
4221 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4222 {
4223 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4224 {
4225 cracked = 0;
4226 break;
4227 }
4228 }
4229 }
4230 }
4231 else
4232 {
4233 char *digests_buf_ptr = (char *) data.digests_buf;
4234
4235 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4236
4237 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4238 }
4239
4240 if (cracked == 1)
4241 {
4242 found = 1;
4243
4244 data.digests_shown[idx] = 1;
4245
4246 data.digests_done++;
4247
4248 salt_buf->digests_done++;
4249
4250 if (salt_buf->digests_done == salt_buf->digests_cnt)
4251 {
4252 data.salts_shown[salt_pos] = 1;
4253
4254 data.salts_done++;
4255
4256 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4257 }
4258 }
4259 }
4260
4261 if (data.devices_status == STATUS_CRACKED) break;
4262 }
4263 }
4264
4265 if (found) break;
4266
4267 if (data.devices_status == STATUS_CRACKED) break;
4268
4269 iter--;
4270 }
4271
4272 if (data.devices_status == STATUS_CRACKED) break;
4273 }
4274
4275 out_info[j].seek = ftell (fp);
4276
4277 //hc_thread_mutex_unlock (mux_display);
4278
4279 fclose (fp);
4280 }
4281 }
4282 }
4283 }
4284
4285 check_left = outfile_check_timer;
4286 }
4287 }
4288
4289 if (esalt_size) local_free (hash_buf.esalt);
4290
4291 if (isSalted) local_free (hash_buf.salt);
4292
4293 local_free (hash_buf.digest);
4294
4295 local_free (out_info);
4296
4297 local_free (out_files);
4298
4299 p = NULL;
4300
4301 return (p);
4302 }
4303
4304 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4305 {
4306 if (device_param->pws_cnt < device_param->kernel_power)
4307 {
4308 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4309
4310 memcpy (pw->i, pw_buf, pw_len);
4311
4312 pw->pw_len = pw_len;
4313
4314 device_param->pws_cnt++;
4315 }
4316 else
4317 {
4318 fprintf (stderr, "BUG pw_add()!!\n");
4319
4320 return;
4321 }
4322 }
4323
4324 static uint get_work (hc_device_param_t *device_param, const u64 max)
4325 {
4326 hc_thread_mutex_lock (mux_dispatcher);
4327
4328 const u64 words_cur = data.words_cur;
4329 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4330
4331 device_param->words_off = words_cur;
4332
4333 const u64 words_left = words_base - words_cur;
4334
4335 if (data.kernel_power_all > words_left)
4336 {
4337 if (data.kernel_power_div == 0)
4338 {
4339 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4340 }
4341 }
4342
4343 if (data.kernel_power_div)
4344 {
4345 if (device_param->kernel_power == device_param->kernel_power_user)
4346 {
4347 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4348
4349 if (kernel_power_new < device_param->kernel_power)
4350 {
4351 device_param->kernel_power = kernel_power_new;
4352 }
4353 }
4354 }
4355
4356 const uint kernel_power = device_param->kernel_power;
4357
4358 uint work = MIN (words_left, kernel_power);
4359
4360 work = MIN (work, max);
4361
4362 data.words_cur += work;
4363
4364 hc_thread_mutex_unlock (mux_dispatcher);
4365
4366 return work;
4367 }
4368
4369 static void *thread_calc_stdin (void *p)
4370 {
4371 hc_device_param_t *device_param = (hc_device_param_t *) p;
4372
4373 if (device_param->skipped) return NULL;
4374
4375 autotune (device_param);
4376
4377 const uint attack_kern = data.attack_kern;
4378
4379 const uint kernel_power = device_param->kernel_power;
4380
4381 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4382 {
4383 hc_thread_mutex_lock (mux_dispatcher);
4384
4385 if (feof (stdin) != 0)
4386 {
4387 hc_thread_mutex_unlock (mux_dispatcher);
4388
4389 break;
4390 }
4391
4392 uint words_cur = 0;
4393
4394 while (words_cur < kernel_power)
4395 {
4396 char buf[BUFSIZ] = { 0 };
4397
4398 char *line_buf = fgets (buf, sizeof (buf), stdin);
4399
4400 if (line_buf == NULL) break;
4401
4402 uint line_len = in_superchop (line_buf);
4403
4404 line_len = convert_from_hex (line_buf, line_len);
4405
4406 // post-process rule engine
4407
4408 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4409 {
4410 char rule_buf_out[BLOCK_SIZE] = { 0 };
4411
4412 int rule_len_out = -1;
4413
4414 if (line_len < BLOCK_SIZE)
4415 {
4416 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4417 }
4418
4419 if (rule_len_out < 0) continue;
4420
4421 line_buf = rule_buf_out;
4422 line_len = rule_len_out;
4423 }
4424
4425 if (line_len > PW_MAX)
4426 {
4427 continue;
4428 }
4429
4430 if (attack_kern == ATTACK_KERN_STRAIGHT)
4431 {
4432 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4433 {
4434 hc_thread_mutex_lock (mux_counter);
4435
4436 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4437 {
4438 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4439 }
4440
4441 hc_thread_mutex_unlock (mux_counter);
4442
4443 continue;
4444 }
4445 }
4446 else if (attack_kern == ATTACK_KERN_COMBI)
4447 {
4448 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4449 // since we still need to combine the plains
4450
4451 if (line_len > data.pw_max)
4452 {
4453 hc_thread_mutex_lock (mux_counter);
4454
4455 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4456 {
4457 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4458 }
4459
4460 hc_thread_mutex_unlock (mux_counter);
4461
4462 continue;
4463 }
4464 }
4465
4466 pw_add (device_param, (u8 *) line_buf, line_len);
4467
4468 words_cur++;
4469
4470 if (data.devices_status == STATUS_CRACKED) break;
4471 if (data.devices_status == STATUS_ABORTED) break;
4472 if (data.devices_status == STATUS_QUIT) break;
4473 if (data.devices_status == STATUS_BYPASS) break;
4474 }
4475
4476 hc_thread_mutex_unlock (mux_dispatcher);
4477
4478 if (data.devices_status == STATUS_CRACKED) break;
4479 if (data.devices_status == STATUS_ABORTED) break;
4480 if (data.devices_status == STATUS_QUIT) break;
4481 if (data.devices_status == STATUS_BYPASS) break;
4482
4483 // flush
4484
4485 const uint pws_cnt = device_param->pws_cnt;
4486
4487 if (pws_cnt)
4488 {
4489 run_copy (device_param, pws_cnt);
4490
4491 run_cracker (device_param, pws_cnt);
4492
4493 device_param->pws_cnt = 0;
4494 }
4495 }
4496
4497 device_param->kernel_accel = 0;
4498 device_param->kernel_loops = 0;
4499
4500 return NULL;
4501 }
4502
4503 static void *thread_calc (void *p)
4504 {
4505 hc_device_param_t *device_param = (hc_device_param_t *) p;
4506
4507 if (device_param->skipped) return NULL;
4508
4509 autotune (device_param);
4510
4511 const uint attack_mode = data.attack_mode;
4512 const uint attack_kern = data.attack_kern;
4513
4514 if (attack_mode == ATTACK_MODE_BF)
4515 {
4516 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4517 {
4518 const uint work = get_work (device_param, -1);
4519
4520 if (work == 0) break;
4521
4522 const u64 words_off = device_param->words_off;
4523 const u64 words_fin = words_off + work;
4524
4525 const uint pws_cnt = work;
4526
4527 device_param->pws_cnt = pws_cnt;
4528
4529 if (pws_cnt)
4530 {
4531 run_copy (device_param, pws_cnt);
4532
4533 run_cracker (device_param, pws_cnt);
4534
4535 device_param->pws_cnt = 0;
4536 }
4537
4538 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4539
4540 if (data.devices_status == STATUS_CRACKED) break;
4541 if (data.devices_status == STATUS_ABORTED) break;
4542 if (data.devices_status == STATUS_QUIT) break;
4543 if (data.devices_status == STATUS_BYPASS) break;
4544
4545 if (data.benchmark == 1) break;
4546
4547 device_param->words_done = words_fin;
4548 }
4549 }
4550 else
4551 {
4552 const uint segment_size = data.segment_size;
4553
4554 char *dictfile = data.dictfile;
4555
4556 if (attack_mode == ATTACK_MODE_COMBI)
4557 {
4558 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4559 {
4560 dictfile = data.dictfile2;
4561 }
4562 }
4563
4564 FILE *fd = fopen (dictfile, "rb");
4565
4566 if (fd == NULL)
4567 {
4568 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4569
4570 return NULL;
4571 }
4572
4573 if (attack_mode == ATTACK_MODE_COMBI)
4574 {
4575 const uint combs_mode = data.combs_mode;
4576
4577 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4578 {
4579 const char *dictfilec = data.dictfile2;
4580
4581 FILE *combs_fp = fopen (dictfilec, "rb");
4582
4583 if (combs_fp == NULL)
4584 {
4585 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4586
4587 fclose (fd);
4588
4589 return NULL;
4590 }
4591
4592 device_param->combs_fp = combs_fp;
4593 }
4594 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4595 {
4596 const char *dictfilec = data.dictfile;
4597
4598 FILE *combs_fp = fopen (dictfilec, "rb");
4599
4600 if (combs_fp == NULL)
4601 {
4602 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4603
4604 fclose (fd);
4605
4606 return NULL;
4607 }
4608
4609 device_param->combs_fp = combs_fp;
4610 }
4611 }
4612
4613 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4614
4615 wl_data->buf = (char *) mymalloc (segment_size);
4616 wl_data->avail = segment_size;
4617 wl_data->incr = segment_size;
4618 wl_data->cnt = 0;
4619 wl_data->pos = 0;
4620
4621 u64 words_cur = 0;
4622
4623 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4624 {
4625 u64 words_off = 0;
4626 u64 words_fin = 0;
4627
4628 u64 max = -1;
4629
4630 while (max)
4631 {
4632 const uint work = get_work (device_param, max);
4633
4634 if (work == 0) break;
4635
4636 words_off = device_param->words_off;
4637 words_fin = words_off + work;
4638
4639 char *line_buf;
4640 uint line_len;
4641
4642 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4643
4644 max = 0;
4645
4646 for ( ; words_cur < words_fin; words_cur++)
4647 {
4648 get_next_word (wl_data, fd, &line_buf, &line_len);
4649
4650 line_len = convert_from_hex (line_buf, line_len);
4651
4652 // post-process rule engine
4653
4654 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4655 {
4656 char rule_buf_out[BLOCK_SIZE] = { 0 };
4657
4658 int rule_len_out = -1;
4659
4660 if (line_len < BLOCK_SIZE)
4661 {
4662 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4663 }
4664
4665 if (rule_len_out < 0) continue;
4666
4667 line_buf = rule_buf_out;
4668 line_len = rule_len_out;
4669 }
4670
4671 if (attack_kern == ATTACK_KERN_STRAIGHT)
4672 {
4673 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4674 {
4675 max++;
4676
4677 hc_thread_mutex_lock (mux_counter);
4678
4679 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4680 {
4681 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4682 }
4683
4684 hc_thread_mutex_unlock (mux_counter);
4685
4686 continue;
4687 }
4688 }
4689 else if (attack_kern == ATTACK_KERN_COMBI)
4690 {
4691 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4692 // since we still need to combine the plains
4693
4694 if (line_len > data.pw_max)
4695 {
4696 max++;
4697
4698 hc_thread_mutex_lock (mux_counter);
4699
4700 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4701 {
4702 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4703 }
4704
4705 hc_thread_mutex_unlock (mux_counter);
4706
4707 continue;
4708 }
4709 }
4710
4711 pw_add (device_param, (u8 *) line_buf, line_len);
4712
4713 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4714
4715 if (data.devices_status == STATUS_CRACKED) break;
4716 if (data.devices_status == STATUS_ABORTED) break;
4717 if (data.devices_status == STATUS_QUIT) break;
4718 if (data.devices_status == STATUS_BYPASS) break;
4719 }
4720
4721 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4722
4723 if (data.devices_status == STATUS_CRACKED) break;
4724 if (data.devices_status == STATUS_ABORTED) break;
4725 if (data.devices_status == STATUS_QUIT) break;
4726 if (data.devices_status == STATUS_BYPASS) break;
4727 }
4728
4729 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4730
4731 if (data.devices_status == STATUS_CRACKED) break;
4732 if (data.devices_status == STATUS_ABORTED) break;
4733 if (data.devices_status == STATUS_QUIT) break;
4734 if (data.devices_status == STATUS_BYPASS) break;
4735
4736 //
4737 // flush
4738 //
4739
4740 const uint pws_cnt = device_param->pws_cnt;
4741
4742 if (pws_cnt)
4743 {
4744 run_copy (device_param, pws_cnt);
4745
4746 run_cracker (device_param, pws_cnt);
4747
4748 device_param->pws_cnt = 0;
4749 }
4750
4751 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4752
4753 if (data.devices_status == STATUS_CRACKED) break;
4754 if (data.devices_status == STATUS_ABORTED) break;
4755 if (data.devices_status == STATUS_QUIT) break;
4756 if (data.devices_status == STATUS_BYPASS) break;
4757
4758 if (words_fin == 0) break;
4759
4760 device_param->words_done = words_fin;
4761 }
4762
4763 if (attack_mode == ATTACK_MODE_COMBI)
4764 {
4765 fclose (device_param->combs_fp);
4766 }
4767
4768 free (wl_data->buf);
4769 free (wl_data);
4770
4771 fclose (fd);
4772 }
4773
4774 device_param->kernel_accel = 0;
4775 device_param->kernel_loops = 0;
4776
4777 return NULL;
4778 }
4779
4780 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4781 {
4782 if (!device_param)
4783 {
4784 log_error ("ERROR: %s : Invalid argument", __func__);
4785
4786 exit (-1);
4787 }
4788
4789 salt_t *salt_buf = &data.salts_buf[salt_pos];
4790
4791 device_param->kernel_params_buf32[24] = salt_pos;
4792 device_param->kernel_params_buf32[27] = 1;
4793 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4794 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4795 device_param->kernel_params_buf32[30] = 0;
4796 device_param->kernel_params_buf32[31] = 1;
4797
4798 char *dictfile_old = data.dictfile;
4799
4800 const char *weak_hash_check = "weak-hash-check";
4801
4802 data.dictfile = (char *) weak_hash_check;
4803
4804 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4805
4806 data.kernel_rules_buf[0].cmds[0] = 0;
4807
4808 /**
4809 * run the kernel
4810 */
4811
4812 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4813 {
4814 run_kernel (KERN_RUN_1, device_param, 1, false);
4815 }
4816 else
4817 {
4818 run_kernel (KERN_RUN_1, device_param, 1, false);
4819
4820 uint loop_step = 16;
4821
4822 const uint iter = salt_buf->salt_iter;
4823
4824 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4825 {
4826 uint loop_left = iter - loop_pos;
4827
4828 loop_left = MIN (loop_left, loop_step);
4829
4830 device_param->kernel_params_buf32[25] = loop_pos;
4831 device_param->kernel_params_buf32[26] = loop_left;
4832
4833 run_kernel (KERN_RUN_2, device_param, 1, false);
4834 }
4835
4836 run_kernel (KERN_RUN_3, device_param, 1, false);
4837 }
4838
4839 /**
4840 * result
4841 */
4842
4843 check_cracked (device_param, salt_pos);
4844
4845 /**
4846 * cleanup
4847 */
4848
4849 device_param->kernel_params_buf32[24] = 0;
4850 device_param->kernel_params_buf32[25] = 0;
4851 device_param->kernel_params_buf32[26] = 0;
4852 device_param->kernel_params_buf32[27] = 0;
4853 device_param->kernel_params_buf32[28] = 0;
4854 device_param->kernel_params_buf32[29] = 0;
4855 device_param->kernel_params_buf32[30] = 0;
4856 device_param->kernel_params_buf32[31] = 0;
4857
4858 data.dictfile = dictfile_old;
4859
4860 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4861 }
4862
4863 // hlfmt hashcat
4864
4865 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4866 {
4867 if (data.username == 0)
4868 {
4869 *hashbuf_pos = line_buf;
4870 *hashbuf_len = line_len;
4871 }
4872 else
4873 {
4874 char *pos = line_buf;
4875 int len = line_len;
4876
4877 for (int i = 0; i < line_len; i++, pos++, len--)
4878 {
4879 if (line_buf[i] == data.separator)
4880 {
4881 pos++;
4882
4883 len--;
4884
4885 break;
4886 }
4887 }
4888
4889 *hashbuf_pos = pos;
4890 *hashbuf_len = len;
4891 }
4892 }
4893
4894 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4895 {
4896 char *pos = NULL;
4897 int len = 0;
4898
4899 int sep_cnt = 0;
4900
4901 for (int i = 0; i < line_len; i++)
4902 {
4903 if (line_buf[i] == data.separator)
4904 {
4905 sep_cnt++;
4906
4907 continue;
4908 }
4909
4910 if (sep_cnt == 0)
4911 {
4912 if (pos == NULL) pos = line_buf + i;
4913
4914 len++;
4915 }
4916 }
4917
4918 *userbuf_pos = pos;
4919 *userbuf_len = len;
4920 }
4921
4922 // hlfmt pwdump
4923
4924 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4925 {
4926 int sep_cnt = 0;
4927
4928 int sep2_len = 0;
4929 int sep3_len = 0;
4930
4931 for (int i = 0; i < line_len; i++)
4932 {
4933 if (line_buf[i] == ':')
4934 {
4935 sep_cnt++;
4936
4937 continue;
4938 }
4939
4940 if (sep_cnt == 2) sep2_len++;
4941 if (sep_cnt == 3) sep3_len++;
4942 }
4943
4944 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4945
4946 return 0;
4947 }
4948
4949 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4950 {
4951 char *pos = NULL;
4952 int len = 0;
4953
4954 int sep_cnt = 0;
4955
4956 for (int i = 0; i < line_len; i++)
4957 {
4958 if (line_buf[i] == ':')
4959 {
4960 sep_cnt++;
4961
4962 continue;
4963 }
4964
4965 if (data.hash_mode == 1000)
4966 {
4967 if (sep_cnt == 3)
4968 {
4969 if (pos == NULL) pos = line_buf + i;
4970
4971 len++;
4972 }
4973 }
4974 else if (data.hash_mode == 3000)
4975 {
4976 if (sep_cnt == 2)
4977 {
4978 if (pos == NULL) pos = line_buf + i;
4979
4980 len++;
4981 }
4982 }
4983 }
4984
4985 *hashbuf_pos = pos;
4986 *hashbuf_len = len;
4987 }
4988
4989 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4990 {
4991 char *pos = NULL;
4992 int len = 0;
4993
4994 int sep_cnt = 0;
4995
4996 for (int i = 0; i < line_len; i++)
4997 {
4998 if (line_buf[i] == ':')
4999 {
5000 sep_cnt++;
5001
5002 continue;
5003 }
5004
5005 if (sep_cnt == 0)
5006 {
5007 if (pos == NULL) pos = line_buf + i;
5008
5009 len++;
5010 }
5011 }
5012
5013 *userbuf_pos = pos;
5014 *userbuf_len = len;
5015 }
5016
5017 // hlfmt passwd
5018
5019 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5020 {
5021 int sep_cnt = 0;
5022
5023 char sep5_first = 0;
5024 char sep6_first = 0;
5025
5026 for (int i = 0; i < line_len; i++)
5027 {
5028 if (line_buf[i] == ':')
5029 {
5030 sep_cnt++;
5031
5032 continue;
5033 }
5034
5035 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5036 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5037 }
5038
5039 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5040
5041 return 0;
5042 }
5043
5044 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5045 {
5046 char *pos = NULL;
5047 int len = 0;
5048
5049 int sep_cnt = 0;
5050
5051 for (int i = 0; i < line_len; i++)
5052 {
5053 if (line_buf[i] == ':')
5054 {
5055 sep_cnt++;
5056
5057 continue;
5058 }
5059
5060 if (sep_cnt == 1)
5061 {
5062 if (pos == NULL) pos = line_buf + i;
5063
5064 len++;
5065 }
5066 }
5067
5068 *hashbuf_pos = pos;
5069 *hashbuf_len = len;
5070 }
5071
5072 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_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 == 0)
5089 {
5090 if (pos == NULL) pos = line_buf + i;
5091
5092 len++;
5093 }
5094 }
5095
5096 *userbuf_pos = pos;
5097 *userbuf_len = len;
5098 }
5099
5100 // hlfmt shadow
5101
5102 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5103 {
5104 int sep_cnt = 0;
5105
5106 for (int i = 0; i < line_len; i++)
5107 {
5108 if (line_buf[i] == ':') sep_cnt++;
5109 }
5110
5111 if (sep_cnt == 8) return 1;
5112
5113 return 0;
5114 }
5115
5116 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5117 {
5118 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5119 }
5120
5121 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5122 {
5123 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5124 }
5125
5126 // hlfmt main
5127
5128 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5129 {
5130 switch (hashfile_format)
5131 {
5132 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5133 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5134 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5135 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5136 }
5137 }
5138
5139 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5140 {
5141 switch (hashfile_format)
5142 {
5143 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5144 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5145 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5146 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5147 }
5148 }
5149
5150 static uint hlfmt_detect (FILE *fp, uint max_check)
5151 {
5152 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5153
5154 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5155 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5156
5157 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5158
5159 uint num_check = 0;
5160
5161 while (!feof (fp))
5162 {
5163 char line_buf[BUFSIZ] = { 0 };
5164
5165 int line_len = fgetl (fp, line_buf);
5166
5167 if (line_len == 0) continue;
5168
5169 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5170 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5171 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5172
5173 if (num_check == max_check) break;
5174
5175 num_check++;
5176 }
5177
5178 uint hashlist_format = HLFMT_HASHCAT;
5179
5180 for (int i = 1; i < HLFMTS_CNT; i++)
5181 {
5182 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5183
5184 hashlist_format = i;
5185 }
5186
5187 free (formats_cnt);
5188
5189 return hashlist_format;
5190 }
5191
5192 /**
5193 * some further helper function
5194 */
5195
5196 // wrapper around mymalloc for ADL
5197
5198 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5199 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5200 {
5201 return mymalloc (iSize);
5202 }
5203 #endif
5204
5205 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)
5206 {
5207 u64 collisions = 0;
5208
5209 const uint dgst_pos0 = data.dgst_pos0;
5210 const uint dgst_pos1 = data.dgst_pos1;
5211 const uint dgst_pos2 = data.dgst_pos2;
5212 const uint dgst_pos3 = data.dgst_pos3;
5213
5214 memset (bitmap_a, 0, bitmap_size);
5215 memset (bitmap_b, 0, bitmap_size);
5216 memset (bitmap_c, 0, bitmap_size);
5217 memset (bitmap_d, 0, bitmap_size);
5218
5219 for (uint i = 0; i < digests_cnt; i++)
5220 {
5221 uint *digest_ptr = (uint *) digests_buf_ptr;
5222
5223 digests_buf_ptr += dgst_size;
5224
5225 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5226 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5227 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5228 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5229
5230 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5231 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5232 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5233 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5234
5235 if (bitmap_a[idx0] & val0) collisions++;
5236 if (bitmap_b[idx1] & val1) collisions++;
5237 if (bitmap_c[idx2] & val2) collisions++;
5238 if (bitmap_d[idx3] & val3) collisions++;
5239
5240 bitmap_a[idx0] |= val0;
5241 bitmap_b[idx1] |= val1;
5242 bitmap_c[idx2] |= val2;
5243 bitmap_d[idx3] |= val3;
5244
5245 if (collisions >= collisions_max) return 0x7fffffff;
5246 }
5247
5248 return collisions;
5249 }
5250
5251 /**
5252 * main
5253 */
5254
5255 int main (int argc, char **argv)
5256 {
5257 /**
5258 * To help users a bit
5259 */
5260
5261 char *compute = getenv ("COMPUTE");
5262
5263 if (compute)
5264 {
5265 static char display[100];
5266
5267 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5268
5269 putenv (display);
5270 }
5271 else
5272 {
5273 if (getenv ("DISPLAY") == NULL)
5274 putenv ((char *) "DISPLAY=:0");
5275 }
5276
5277 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5278 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5279
5280 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5281 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5282
5283 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5284 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5285
5286 /**
5287 * Real init
5288 */
5289
5290 memset (&data, 0, sizeof (hc_global_data_t));
5291
5292 time_t proc_start;
5293
5294 time (&proc_start);
5295
5296 data.proc_start = proc_start;
5297
5298 int myargc = argc;
5299 char **myargv = argv;
5300
5301 hc_thread_mutex_init (mux_dispatcher);
5302 hc_thread_mutex_init (mux_counter);
5303 hc_thread_mutex_init (mux_display);
5304 hc_thread_mutex_init (mux_adl);
5305
5306 /**
5307 * commandline parameters
5308 */
5309
5310 uint usage = USAGE;
5311 uint version = VERSION;
5312 uint quiet = QUIET;
5313 uint benchmark = BENCHMARK;
5314 uint benchmark_repeats = BENCHMARK_REPEATS;
5315 uint show = SHOW;
5316 uint left = LEFT;
5317 uint username = USERNAME;
5318 uint remove = REMOVE;
5319 uint remove_timer = REMOVE_TIMER;
5320 u64 skip = SKIP;
5321 u64 limit = LIMIT;
5322 uint keyspace = KEYSPACE;
5323 uint potfile_disable = POTFILE_DISABLE;
5324 uint debug_mode = DEBUG_MODE;
5325 char *debug_file = NULL;
5326 char *induction_dir = NULL;
5327 char *outfile_check_dir = NULL;
5328 uint force = FORCE;
5329 uint runtime = RUNTIME;
5330 uint hash_mode = HASH_MODE;
5331 uint attack_mode = ATTACK_MODE;
5332 uint markov_disable = MARKOV_DISABLE;
5333 uint markov_classic = MARKOV_CLASSIC;
5334 uint markov_threshold = MARKOV_THRESHOLD;
5335 char *markov_hcstat = NULL;
5336 char *outfile = NULL;
5337 uint outfile_format = OUTFILE_FORMAT;
5338 uint outfile_autohex = OUTFILE_AUTOHEX;
5339 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5340 uint restore = RESTORE;
5341 uint restore_timer = RESTORE_TIMER;
5342 uint restore_disable = RESTORE_DISABLE;
5343 uint status = STATUS;
5344 uint status_timer = STATUS_TIMER;
5345 uint status_automat = STATUS_AUTOMAT;
5346 uint loopback = LOOPBACK;
5347 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5348 char *session = NULL;
5349 uint hex_charset = HEX_CHARSET;
5350 uint hex_salt = HEX_SALT;
5351 uint hex_wordlist = HEX_WORDLIST;
5352 uint rp_gen = RP_GEN;
5353 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5354 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5355 uint rp_gen_seed = RP_GEN_SEED;
5356 char *rule_buf_l = (char *) RULE_BUF_L;
5357 char *rule_buf_r = (char *) RULE_BUF_R;
5358 uint increment = INCREMENT;
5359 uint increment_min = INCREMENT_MIN;
5360 uint increment_max = INCREMENT_MAX;
5361 char *cpu_affinity = NULL;
5362 OCL_PTR *ocl = NULL;
5363 char *opencl_devices = NULL;
5364 char *opencl_platforms = NULL;
5365 char *opencl_device_types = NULL;
5366 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5367 char *truecrypt_keyfiles = NULL;
5368 uint workload_profile = WORKLOAD_PROFILE;
5369 uint kernel_accel = KERNEL_ACCEL;
5370 uint kernel_loops = KERNEL_LOOPS;
5371 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5372 #ifdef HAVE_HWMON
5373 uint gpu_temp_abort = GPU_TEMP_ABORT;
5374 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5375 #ifdef HAVE_ADL
5376 uint powertune_enable = POWERTUNE_ENABLE;
5377 #endif
5378 #endif
5379 uint logfile_disable = LOGFILE_DISABLE;
5380 uint segment_size = SEGMENT_SIZE;
5381 uint scrypt_tmto = SCRYPT_TMTO;
5382 char separator = SEPARATOR;
5383 uint bitmap_min = BITMAP_MIN;
5384 uint bitmap_max = BITMAP_MAX;
5385 char *custom_charset_1 = NULL;
5386 char *custom_charset_2 = NULL;
5387 char *custom_charset_3 = NULL;
5388 char *custom_charset_4 = NULL;
5389
5390 #define IDX_HELP 'h'
5391 #define IDX_VERSION 'V'
5392 #define IDX_VERSION_LOWER 'v'
5393 #define IDX_QUIET 0xff02
5394 #define IDX_SHOW 0xff03
5395 #define IDX_LEFT 0xff04
5396 #define IDX_REMOVE 0xff05
5397 #define IDX_REMOVE_TIMER 0xff37
5398 #define IDX_SKIP 's'
5399 #define IDX_LIMIT 'l'
5400 #define IDX_KEYSPACE 0xff35
5401 #define IDX_POTFILE_DISABLE 0xff06
5402 #define IDX_DEBUG_MODE 0xff43
5403 #define IDX_DEBUG_FILE 0xff44
5404 #define IDX_INDUCTION_DIR 0xff46
5405 #define IDX_OUTFILE_CHECK_DIR 0xff47
5406 #define IDX_USERNAME 0xff07
5407 #define IDX_FORCE 0xff08
5408 #define IDX_RUNTIME 0xff09
5409 #define IDX_BENCHMARK 'b'
5410 #define IDX_BENCHMARK_REPEATS 0xff78
5411 #define IDX_HASH_MODE 'm'
5412 #define IDX_ATTACK_MODE 'a'
5413 #define IDX_RP_FILE 'r'
5414 #define IDX_RP_GEN 'g'
5415 #define IDX_RP_GEN_FUNC_MIN 0xff10
5416 #define IDX_RP_GEN_FUNC_MAX 0xff11
5417 #define IDX_RP_GEN_SEED 0xff34
5418 #define IDX_RULE_BUF_L 'j'
5419 #define IDX_RULE_BUF_R 'k'
5420 #define IDX_INCREMENT 'i'
5421 #define IDX_INCREMENT_MIN 0xff12
5422 #define IDX_INCREMENT_MAX 0xff13
5423 #define IDX_OUTFILE 'o'
5424 #define IDX_OUTFILE_FORMAT 0xff14
5425 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5426 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5427 #define IDX_RESTORE 0xff15
5428 #define IDX_RESTORE_DISABLE 0xff27
5429 #define IDX_STATUS 0xff17
5430 #define IDX_STATUS_TIMER 0xff18
5431 #define IDX_STATUS_AUTOMAT 0xff50
5432 #define IDX_LOOPBACK 0xff38
5433 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5434 #define IDX_SESSION 0xff19
5435 #define IDX_HEX_CHARSET 0xff20
5436 #define IDX_HEX_SALT 0xff21
5437 #define IDX_HEX_WORDLIST 0xff40
5438 #define IDX_MARKOV_DISABLE 0xff22
5439 #define IDX_MARKOV_CLASSIC 0xff23
5440 #define IDX_MARKOV_THRESHOLD 't'
5441 #define IDX_MARKOV_HCSTAT 0xff24
5442 #define IDX_CPU_AFFINITY 0xff25
5443 #define IDX_OPENCL_DEVICES 'd'
5444 #define IDX_OPENCL_PLATFORMS 0xff72
5445 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5446 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5447 #define IDX_WORKLOAD_PROFILE 'w'
5448 #define IDX_KERNEL_ACCEL 'n'
5449 #define IDX_KERNEL_LOOPS 'u'
5450 #define IDX_GPU_TEMP_DISABLE 0xff29
5451 #define IDX_GPU_TEMP_ABORT 0xff30
5452 #define IDX_GPU_TEMP_RETAIN 0xff31
5453 #define IDX_POWERTUNE_ENABLE 0xff41
5454 #define IDX_LOGFILE_DISABLE 0xff51
5455 #define IDX_TRUECRYPT_KEYFILES 0xff52
5456 #define IDX_SCRYPT_TMTO 0xff61
5457 #define IDX_SEGMENT_SIZE 'c'
5458 #define IDX_SEPARATOR 'p'
5459 #define IDX_BITMAP_MIN 0xff70
5460 #define IDX_BITMAP_MAX 0xff71
5461 #define IDX_CUSTOM_CHARSET_1 '1'
5462 #define IDX_CUSTOM_CHARSET_2 '2'
5463 #define IDX_CUSTOM_CHARSET_3 '3'
5464 #define IDX_CUSTOM_CHARSET_4 '4'
5465
5466 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5467
5468 struct option long_options[] =
5469 {
5470 {"help", no_argument, 0, IDX_HELP},
5471 {"version", no_argument, 0, IDX_VERSION},
5472 {"quiet", no_argument, 0, IDX_QUIET},
5473 {"show", no_argument, 0, IDX_SHOW},
5474 {"left", no_argument, 0, IDX_LEFT},
5475 {"username", no_argument, 0, IDX_USERNAME},
5476 {"remove", no_argument, 0, IDX_REMOVE},
5477 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5478 {"skip", required_argument, 0, IDX_SKIP},
5479 {"limit", required_argument, 0, IDX_LIMIT},
5480 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5481 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5482 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5483 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5484 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5485 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5486 {"force", no_argument, 0, IDX_FORCE},
5487 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5488 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5489 {"restore", no_argument, 0, IDX_RESTORE},
5490 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5491 {"status", no_argument, 0, IDX_STATUS},
5492 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5493 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5494 {"loopback", no_argument, 0, IDX_LOOPBACK},
5495 {"weak-hash-threshold",
5496 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5497 {"session", required_argument, 0, IDX_SESSION},
5498 {"runtime", required_argument, 0, IDX_RUNTIME},
5499 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5500 {"generate-rules-func-min",
5501 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5502 {"generate-rules-func-max",
5503 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5504 {"generate-rules-seed",
5505 required_argument, 0, IDX_RP_GEN_SEED},
5506 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5507 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5508 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5509 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5510 {"rules-file", required_argument, 0, IDX_RP_FILE},
5511 {"outfile", required_argument, 0, IDX_OUTFILE},
5512 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5513 {"outfile-autohex-disable",
5514 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5515 {"outfile-check-timer",
5516 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5517 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5518 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5519 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5520 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5521 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5522 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5523 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5524 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5525 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5526 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5527 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5528 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5529 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5530 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5531 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5532 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5533 #ifdef HAVE_HWMON
5534 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5535 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5536 #ifdef HAVE_ADL
5537 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5538 #endif
5539 #endif // HAVE_HWMON
5540 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5541 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5542 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5543 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5544 // deprecated
5545 {"seperator", required_argument, 0, IDX_SEPARATOR},
5546 {"separator", required_argument, 0, IDX_SEPARATOR},
5547 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5548 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5549 {"increment", no_argument, 0, IDX_INCREMENT},
5550 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5551 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5552 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5553 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5554 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5555 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5556
5557 {0, 0, 0, 0}
5558 };
5559
5560 uint rp_files_cnt = 0;
5561
5562 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5563
5564 int option_index = 0;
5565 int c = -1;
5566
5567 optind = 1;
5568 optopt = 0;
5569
5570 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5571 {
5572 switch (c)
5573 {
5574 case IDX_HELP: usage = 1; break;
5575 case IDX_VERSION:
5576 case IDX_VERSION_LOWER: version = 1; break;
5577 case IDX_RESTORE: restore = 1; break;
5578 case IDX_SESSION: session = optarg; break;
5579 case IDX_SHOW: show = 1; break;
5580 case IDX_LEFT: left = 1; break;
5581 case '?': return (-1);
5582 }
5583 }
5584
5585 if (optopt != 0)
5586 {
5587 log_error ("ERROR: Invalid argument specified");
5588
5589 return (-1);
5590 }
5591
5592 /**
5593 * exit functions
5594 */
5595
5596 if (version)
5597 {
5598 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5599
5600 return (0);
5601 }
5602
5603 if (usage)
5604 {
5605 usage_big_print (PROGNAME);
5606
5607 return (0);
5608 }
5609
5610 /**
5611 * session needs to be set, always!
5612 */
5613
5614 if (session == NULL) session = (char *) PROGNAME;
5615
5616 /**
5617 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5618 */
5619
5620 char *exec_path = get_exec_path ();
5621
5622 #ifdef LINUX
5623
5624 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5625 char *resolved_exec_path = realpath (exec_path, NULL);
5626
5627 char *install_dir = get_install_dir (resolved_exec_path);
5628 char *profile_dir = NULL;
5629 char *session_dir = NULL;
5630 char *shared_dir = NULL;
5631
5632 if (strcmp (install_dir, resolved_install_folder) == 0)
5633 {
5634 struct passwd *pw = getpwuid (getuid ());
5635
5636 const char *homedir = pw->pw_dir;
5637
5638 profile_dir = get_profile_dir (homedir);
5639 session_dir = get_session_dir (profile_dir);
5640 shared_dir = strdup (SHARED_FOLDER);
5641
5642 mkdir (profile_dir, 0700);
5643 mkdir (session_dir, 0700);
5644 }
5645 else
5646 {
5647 profile_dir = install_dir;
5648 session_dir = install_dir;
5649 shared_dir = install_dir;
5650 }
5651
5652 myfree (resolved_install_folder);
5653 myfree (resolved_exec_path);
5654
5655 #else
5656
5657 char *install_dir = get_install_dir (exec_path);
5658 char *profile_dir = install_dir;
5659 char *session_dir = install_dir;
5660 char *shared_dir = install_dir;
5661
5662 #endif
5663
5664 data.install_dir = install_dir;
5665 data.profile_dir = profile_dir;
5666 data.session_dir = session_dir;
5667 data.shared_dir = shared_dir;
5668
5669 myfree (exec_path);
5670
5671 /**
5672 * kernel cache, we need to make sure folder exist
5673 */
5674
5675 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5676
5677 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5678
5679 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5680
5681 mkdir (kernels_folder, 0700);
5682
5683 myfree (kernels_folder);
5684
5685 /**
5686 * session
5687 */
5688
5689 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5690
5691 data.session = session;
5692
5693 char *eff_restore_file = (char *) mymalloc (session_size);
5694 char *new_restore_file = (char *) mymalloc (session_size);
5695
5696 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5697 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5698
5699 data.eff_restore_file = eff_restore_file;
5700 data.new_restore_file = new_restore_file;
5701
5702 if (((show == 1) || (left == 1)) && (restore == 1))
5703 {
5704 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5705 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5706
5707 return (-1);
5708 }
5709
5710 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5711 if ((show == 1) || (left == 1))
5712 {
5713 restore_disable = 1;
5714
5715 restore = 0;
5716 }
5717
5718 data.restore_disable = restore_disable;
5719
5720 restore_data_t *rd = init_restore (argc, argv);
5721
5722 data.rd = rd;
5723
5724 /**
5725 * restore file
5726 */
5727
5728 if (restore == 1)
5729 {
5730 read_restore (eff_restore_file, rd);
5731
5732 if (rd->version_bin < RESTORE_MIN)
5733 {
5734 log_error ("ERROR: Incompatible restore-file version");
5735
5736 return (-1);
5737 }
5738
5739 myargc = rd->argc;
5740 myargv = rd->argv;
5741
5742 #ifdef _POSIX
5743 rd->pid = getpid ();
5744 #elif _WIN
5745 rd->pid = GetCurrentProcessId ();
5746 #endif
5747 }
5748
5749 uint hash_mode_chgd = 0;
5750 uint runtime_chgd = 0;
5751 uint kernel_loops_chgd = 0;
5752 uint kernel_accel_chgd = 0;
5753 uint attack_mode_chgd = 0;
5754 uint outfile_format_chgd = 0;
5755 uint rp_gen_seed_chgd = 0;
5756 uint remove_timer_chgd = 0;
5757 uint increment_min_chgd = 0;
5758 uint increment_max_chgd = 0;
5759 uint workload_profile_chgd = 0;
5760 uint opencl_vector_width_chgd = 0;
5761
5762 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5763 uint gpu_temp_retain_chgd = 0;
5764 uint gpu_temp_abort_chgd = 0;
5765 #endif
5766
5767 optind = 1;
5768 optopt = 0;
5769 option_index = 0;
5770
5771 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5772 {
5773 switch (c)
5774 {
5775 //case IDX_HELP: usage = 1; break;
5776 //case IDX_VERSION: version = 1; break;
5777 //case IDX_RESTORE: restore = 1; break;
5778 case IDX_QUIET: quiet = 1; break;
5779 //case IDX_SHOW: show = 1; break;
5780 case IDX_SHOW: break;
5781 //case IDX_LEFT: left = 1; break;
5782 case IDX_LEFT: break;
5783 case IDX_USERNAME: username = 1; break;
5784 case IDX_REMOVE: remove = 1; break;
5785 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5786 remove_timer_chgd = 1; break;
5787 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5788 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5789 case IDX_DEBUG_FILE: debug_file = optarg; break;
5790 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5791 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5792 case IDX_FORCE: force = 1; break;
5793 case IDX_SKIP: skip = atoll (optarg); break;
5794 case IDX_LIMIT: limit = atoll (optarg); break;
5795 case IDX_KEYSPACE: keyspace = 1; break;
5796 case IDX_BENCHMARK: benchmark = 1; break;
5797 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5798 case IDX_RESTORE: break;
5799 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5800 case IDX_STATUS: status = 1; break;
5801 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5802 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5803 case IDX_LOOPBACK: loopback = 1; break;
5804 case IDX_WEAK_HASH_THRESHOLD:
5805 weak_hash_threshold = atoi (optarg); break;
5806 //case IDX_SESSION: session = optarg; break;
5807 case IDX_SESSION: break;
5808 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5809 hash_mode_chgd = 1; break;
5810 case IDX_RUNTIME: runtime = atoi (optarg);
5811 runtime_chgd = 1; break;
5812 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5813 attack_mode_chgd = 1; break;
5814 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5815 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5816 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5817 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5818 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5819 rp_gen_seed_chgd = 1; break;
5820 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5821 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5822 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5823 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5824 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5825 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5826 case IDX_OUTFILE: outfile = optarg; break;
5827 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5828 outfile_format_chgd = 1; break;
5829 case IDX_OUTFILE_AUTOHEX_DISABLE:
5830 outfile_autohex = 0; break;
5831 case IDX_OUTFILE_CHECK_TIMER:
5832 outfile_check_timer = atoi (optarg); break;
5833 case IDX_HEX_CHARSET: hex_charset = 1; break;
5834 case IDX_HEX_SALT: hex_salt = 1; break;
5835 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5836 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5837 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5838 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5839 case IDX_OPENCL_DEVICE_TYPES:
5840 opencl_device_types = optarg; break;
5841 case IDX_OPENCL_VECTOR_WIDTH:
5842 opencl_vector_width = atoi (optarg);
5843 opencl_vector_width_chgd = 1; break;
5844 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5845 workload_profile_chgd = 1; break;
5846 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5847 kernel_accel_chgd = 1; break;
5848 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5849 kernel_loops_chgd = 1; break;
5850 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5851 #ifdef HAVE_HWMON
5852 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5853 #ifdef HAVE_ADL
5854 gpu_temp_abort_chgd = 1;
5855 #endif
5856 break;
5857 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5858 #ifdef HAVE_ADL
5859 gpu_temp_retain_chgd = 1;
5860 #endif
5861 break;
5862 #ifdef HAVE_ADL
5863 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5864 #endif
5865 #endif // HAVE_HWMON
5866 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5867 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5868 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5869 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5870 case IDX_SEPARATOR: separator = optarg[0]; break;
5871 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5872 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5873 case IDX_INCREMENT: increment = 1; break;
5874 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5875 increment_min_chgd = 1; break;
5876 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5877 increment_max_chgd = 1; break;
5878 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5879 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5880 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5881 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5882
5883 default:
5884 log_error ("ERROR: Invalid argument specified");
5885 return (-1);
5886 }
5887 }
5888
5889 if (optopt != 0)
5890 {
5891 log_error ("ERROR: Invalid argument specified");
5892
5893 return (-1);
5894 }
5895
5896 /**
5897 * Inform user things getting started,
5898 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5899 * - we do not need to check algorithm_pos
5900 */
5901
5902 if (quiet == 0)
5903 {
5904 if (benchmark == 1)
5905 {
5906 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5907
5908 log_info ("");
5909 }
5910 else if (restore == 1)
5911 {
5912 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5913
5914 log_info ("");
5915 }
5916 else
5917 {
5918 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5919
5920 log_info ("");
5921 }
5922 }
5923
5924 /**
5925 * sanity check
5926 */
5927
5928 if (attack_mode > 7)
5929 {
5930 log_error ("ERROR: Invalid attack-mode specified");
5931
5932 return (-1);
5933 }
5934
5935 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5936 {
5937 log_error ("ERROR: Invalid runtime specified");
5938
5939 return (-1);
5940 }
5941
5942 if (hash_mode_chgd && hash_mode > 13100) // just added to remove compiler warnings for hash_mode_chgd
5943 {
5944 log_error ("ERROR: Invalid hash-type specified");
5945
5946 return (-1);
5947 }
5948
5949 // renamed hash modes
5950
5951 if (hash_mode_chgd)
5952 {
5953 int n = -1;
5954
5955 switch (hash_mode)
5956 {
5957 case 123: n = 124;
5958 break;
5959 }
5960
5961 if (n >= 0)
5962 {
5963 log_error ("Old -m specified, use -m %d instead", n);
5964
5965 return (-1);
5966 }
5967 }
5968
5969 if (username == 1)
5970 {
5971 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5972 {
5973 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5974
5975 return (-1);
5976 }
5977 }
5978
5979 if (outfile_format > 16)
5980 {
5981 log_error ("ERROR: Invalid outfile-format specified");
5982
5983 return (-1);
5984 }
5985
5986 if (left == 1)
5987 {
5988 if (outfile_format_chgd == 1)
5989 {
5990 if (outfile_format > 1)
5991 {
5992 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5993
5994 return (-1);
5995 }
5996 }
5997 else
5998 {
5999 outfile_format = OUTFILE_FMT_HASH;
6000 }
6001 }
6002
6003 if (show == 1)
6004 {
6005 if (outfile_format_chgd == 1)
6006 {
6007 if ((outfile_format > 7) && (outfile_format < 16))
6008 {
6009 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6010
6011 return (-1);
6012 }
6013 }
6014 }
6015
6016 if (increment_min < INCREMENT_MIN)
6017 {
6018 log_error ("ERROR: Invalid increment-min specified");
6019
6020 return (-1);
6021 }
6022
6023 if (increment_max > INCREMENT_MAX)
6024 {
6025 log_error ("ERROR: Invalid increment-max specified");
6026
6027 return (-1);
6028 }
6029
6030 if (increment_min > increment_max)
6031 {
6032 log_error ("ERROR: Invalid increment-min specified");
6033
6034 return (-1);
6035 }
6036
6037 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6038 {
6039 log_error ("ERROR: increment is not allowed in attack-mode 0");
6040
6041 return (-1);
6042 }
6043
6044 if ((increment == 0) && (increment_min_chgd == 1))
6045 {
6046 log_error ("ERROR: increment-min is only supported together with increment switch");
6047
6048 return (-1);
6049 }
6050
6051 if ((increment == 0) && (increment_max_chgd == 1))
6052 {
6053 log_error ("ERROR: increment-max is only supported together with increment switch");
6054
6055 return (-1);
6056 }
6057
6058 if (rp_files_cnt && rp_gen)
6059 {
6060 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6061
6062 return (-1);
6063 }
6064
6065 if (rp_files_cnt || rp_gen)
6066 {
6067 if (attack_mode != ATTACK_MODE_STRAIGHT)
6068 {
6069 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6070
6071 return (-1);
6072 }
6073 }
6074
6075 if (rp_gen_func_min > rp_gen_func_max)
6076 {
6077 log_error ("ERROR: Invalid rp-gen-func-min specified");
6078
6079 return (-1);
6080 }
6081
6082 if (kernel_accel_chgd == 1)
6083 {
6084 if (kernel_accel < 1)
6085 {
6086 log_error ("ERROR: Invalid kernel-accel specified");
6087
6088 return (-1);
6089 }
6090
6091 if (kernel_accel > 1024)
6092 {
6093 log_error ("ERROR: Invalid kernel-accel specified");
6094
6095 return (-1);
6096 }
6097 }
6098
6099 if (kernel_loops_chgd == 1)
6100 {
6101 if (kernel_loops < 1)
6102 {
6103 log_error ("ERROR: Invalid kernel-loops specified");
6104
6105 return (-1);
6106 }
6107
6108 if (kernel_loops > 1024)
6109 {
6110 log_error ("ERROR: Invalid kernel-loops specified");
6111
6112 return (-1);
6113 }
6114 }
6115
6116 if ((workload_profile < 1) || (workload_profile > 3))
6117 {
6118 log_error ("ERROR: workload-profile %i not available", workload_profile);
6119
6120 return (-1);
6121 }
6122
6123 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6124 {
6125 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6126
6127 return (-1);
6128 }
6129
6130 if (show == 1 || left == 1)
6131 {
6132 attack_mode = ATTACK_MODE_NONE;
6133
6134 if (remove == 1)
6135 {
6136 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6137
6138 return (-1);
6139 }
6140
6141 if (potfile_disable == 1)
6142 {
6143 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6144
6145 return (-1);
6146 }
6147 }
6148
6149 uint attack_kern = ATTACK_KERN_NONE;
6150
6151 switch (attack_mode)
6152 {
6153 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6154 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6155 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6156 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6157 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6158 }
6159
6160 if (benchmark == 0)
6161 {
6162 if (keyspace == 1)
6163 {
6164 int num_additional_params = 1;
6165
6166 if (attack_kern == ATTACK_KERN_COMBI)
6167 {
6168 num_additional_params = 2;
6169 }
6170
6171 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6172
6173 if (keyspace_wordlist_specified == 0) optind--;
6174 }
6175
6176 if (attack_kern == ATTACK_KERN_NONE)
6177 {
6178 if ((optind + 1) != myargc)
6179 {
6180 usage_mini_print (myargv[0]);
6181
6182 return (-1);
6183 }
6184 }
6185 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6186 {
6187 if ((optind + 1) > myargc)
6188 {
6189 usage_mini_print (myargv[0]);
6190
6191 return (-1);
6192 }
6193 }
6194 else if (attack_kern == ATTACK_KERN_COMBI)
6195 {
6196 if ((optind + 3) != myargc)
6197 {
6198 usage_mini_print (myargv[0]);
6199
6200 return (-1);
6201 }
6202 }
6203 else if (attack_kern == ATTACK_KERN_BF)
6204 {
6205 if ((optind + 1) > myargc)
6206 {
6207 usage_mini_print (myargv[0]);
6208
6209 return (-1);
6210 }
6211 }
6212 else
6213 {
6214 usage_mini_print (myargv[0]);
6215
6216 return (-1);
6217 }
6218 }
6219 else
6220 {
6221 if (myargv[optind] != 0)
6222 {
6223 log_error ("ERROR: Invalid argument for benchmark mode specified");
6224
6225 return (-1);
6226 }
6227
6228 if (attack_mode_chgd == 1)
6229 {
6230 if (attack_mode != ATTACK_MODE_BF)
6231 {
6232 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6233
6234 return (-1);
6235 }
6236 }
6237 }
6238
6239 if (skip != 0 && limit != 0)
6240 {
6241 limit += skip;
6242 }
6243
6244 if (keyspace == 1)
6245 {
6246 if (show == 1)
6247 {
6248 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6249
6250 return (-1);
6251 }
6252 else if (left == 1)
6253 {
6254 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6255
6256 return (-1);
6257 }
6258
6259 potfile_disable = 1;
6260
6261 restore_disable = 1;
6262
6263 restore = 0;
6264
6265 weak_hash_threshold = 0;
6266
6267 quiet = 1;
6268 }
6269
6270 if (remove_timer_chgd == 1)
6271 {
6272 if (remove == 0)
6273 {
6274 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6275
6276 return (-1);
6277 }
6278
6279 if (remove_timer < 1)
6280 {
6281 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6282
6283 return (-1);
6284 }
6285 }
6286
6287 if (loopback == 1)
6288 {
6289 if (attack_mode == ATTACK_MODE_BF)
6290 {
6291 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6292
6293 return (-1);
6294 }
6295 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6296 {
6297 if ((rp_files_cnt == 0) && (rp_gen == 0))
6298 {
6299 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6300
6301 return (-1);
6302 }
6303 }
6304 }
6305
6306 if (debug_mode > 0)
6307 {
6308 if (attack_mode != ATTACK_MODE_STRAIGHT)
6309 {
6310 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6311
6312 return (-1);
6313 }
6314
6315 if ((rp_files_cnt == 0) && (rp_gen == 0))
6316 {
6317 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6318
6319 return (-1);
6320 }
6321 }
6322
6323 if (debug_mode > 4)
6324 {
6325 log_error ("ERROR: Invalid debug-mode specified");
6326
6327 return (-1);
6328 }
6329
6330 if (debug_file != NULL)
6331 {
6332 if (debug_mode < 1)
6333 {
6334 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6335
6336 return (-1);
6337 }
6338 }
6339
6340 if (induction_dir != NULL)
6341 {
6342 if (attack_mode == ATTACK_MODE_BF)
6343 {
6344 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6345
6346 return (-1);
6347 }
6348 }
6349
6350 if (attack_mode != ATTACK_MODE_STRAIGHT)
6351 {
6352 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6353 {
6354 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6355
6356 return (-1);
6357 }
6358
6359 weak_hash_threshold = 0;
6360 }
6361
6362 /**
6363 * induction directory
6364 */
6365
6366 char *induction_directory = NULL;
6367
6368 if (attack_mode != ATTACK_MODE_BF)
6369 {
6370 if (induction_dir == NULL)
6371 {
6372 induction_directory = (char *) mymalloc (session_size);
6373
6374 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6375
6376 // create induction folder if it does not already exist
6377
6378 if (keyspace == 0)
6379 {
6380 if (rmdir (induction_directory) == -1)
6381 {
6382 if (errno == ENOENT)
6383 {
6384 // good, we can ignore
6385 }
6386 else if (errno == ENOTEMPTY)
6387 {
6388 char *induction_directory_mv = (char *) mymalloc (session_size);
6389
6390 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6391
6392 if (rename (induction_directory, induction_directory_mv) != 0)
6393 {
6394 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6395
6396 return (-1);
6397 }
6398 }
6399 else
6400 {
6401 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6402
6403 return (-1);
6404 }
6405 }
6406
6407 if (mkdir (induction_directory, 0700) == -1)
6408 {
6409 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6410
6411 return (-1);
6412 }
6413 }
6414 }
6415 else
6416 {
6417 induction_directory = induction_dir;
6418 }
6419 }
6420
6421 data.induction_directory = induction_directory;
6422
6423 /**
6424 * loopback
6425 */
6426
6427 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6428
6429 char *loopback_file = (char *) mymalloc (loopback_size);
6430
6431 /**
6432 * tuning db
6433 */
6434
6435 char tuning_db_file[256] = { 0 };
6436
6437 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6438
6439 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6440
6441 /**
6442 * outfile-check directory
6443 */
6444
6445 char *outfile_check_directory = NULL;
6446
6447 if (outfile_check_dir == NULL)
6448 {
6449 outfile_check_directory = (char *) mymalloc (session_size);
6450
6451 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6452 }
6453 else
6454 {
6455 outfile_check_directory = outfile_check_dir;
6456 }
6457
6458 data.outfile_check_directory = outfile_check_directory;
6459
6460 if (keyspace == 0)
6461 {
6462 struct stat outfile_check_stat;
6463
6464 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6465 {
6466 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6467
6468 if (is_dir == 0)
6469 {
6470 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6471
6472 return (-1);
6473 }
6474 }
6475 else if (outfile_check_dir == NULL)
6476 {
6477 if (mkdir (outfile_check_directory, 0700) == -1)
6478 {
6479 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6480
6481 return (-1);
6482 }
6483 }
6484 }
6485
6486 /**
6487 * special other stuff
6488 */
6489
6490 if (hash_mode == 9710)
6491 {
6492 outfile_format = 5;
6493 outfile_format_chgd = 1;
6494 }
6495
6496 if (hash_mode == 9810)
6497 {
6498 outfile_format = 5;
6499 outfile_format_chgd = 1;
6500 }
6501
6502 if (hash_mode == 10410)
6503 {
6504 outfile_format = 5;
6505 outfile_format_chgd = 1;
6506 }
6507
6508 /**
6509 * store stuff
6510 */
6511
6512 data.hash_mode = hash_mode;
6513 data.restore = restore;
6514 data.restore_timer = restore_timer;
6515 data.restore_disable = restore_disable;
6516 data.status = status;
6517 data.status_timer = status_timer;
6518 data.status_automat = status_automat;
6519 data.loopback = loopback;
6520 data.runtime = runtime;
6521 data.remove = remove;
6522 data.remove_timer = remove_timer;
6523 data.debug_mode = debug_mode;
6524 data.debug_file = debug_file;
6525 data.username = username;
6526 data.quiet = quiet;
6527 data.outfile = outfile;
6528 data.outfile_format = outfile_format;
6529 data.outfile_autohex = outfile_autohex;
6530 data.hex_charset = hex_charset;
6531 data.hex_salt = hex_salt;
6532 data.hex_wordlist = hex_wordlist;
6533 data.separator = separator;
6534 data.rp_files = rp_files;
6535 data.rp_files_cnt = rp_files_cnt;
6536 data.rp_gen = rp_gen;
6537 data.rp_gen_seed = rp_gen_seed;
6538 data.force = force;
6539 data.benchmark = benchmark;
6540 data.benchmark_repeats = benchmark_repeats;
6541 data.skip = skip;
6542 data.limit = limit;
6543 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6544 data.powertune_enable = powertune_enable;
6545 #endif
6546 data.logfile_disable = logfile_disable;
6547 data.truecrypt_keyfiles = truecrypt_keyfiles;
6548 data.scrypt_tmto = scrypt_tmto;
6549 data.workload_profile = workload_profile;
6550
6551 /**
6552 * cpu affinity
6553 */
6554
6555 if (cpu_affinity)
6556 {
6557 set_cpu_affinity (cpu_affinity);
6558 }
6559
6560 if (rp_gen_seed_chgd == 0)
6561 {
6562 srand (proc_start);
6563 }
6564 else
6565 {
6566 srand (rp_gen_seed);
6567 }
6568
6569 /**
6570 * logfile init
6571 */
6572
6573 if (logfile_disable == 0)
6574 {
6575 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6576
6577 char *logfile = (char *) mymalloc (logfile_size);
6578
6579 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6580
6581 data.logfile = logfile;
6582
6583 char *topid = logfile_generate_topid ();
6584
6585 data.topid = topid;
6586 }
6587
6588 // logfile_append() checks for logfile_disable internally to make it easier from here
6589
6590 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6591 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6592 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6593 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6594 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6595 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6596 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6597 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6598 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6599 #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));
6600
6601 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6602 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6603 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6604 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6605 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6606 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6607 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6608 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6609
6610 logfile_top_msg ("START");
6611
6612 logfile_top_uint (attack_mode);
6613 logfile_top_uint (attack_kern);
6614 logfile_top_uint (benchmark);
6615 logfile_top_uint (benchmark_repeats);
6616 logfile_top_uint (bitmap_min);
6617 logfile_top_uint (bitmap_max);
6618 logfile_top_uint (debug_mode);
6619 logfile_top_uint (force);
6620 logfile_top_uint (kernel_accel);
6621 logfile_top_uint (kernel_loops);
6622 logfile_top_uint (gpu_temp_disable);
6623 #ifdef HAVE_HWMON
6624 logfile_top_uint (gpu_temp_abort);
6625 logfile_top_uint (gpu_temp_retain);
6626 #endif
6627 logfile_top_uint (hash_mode);
6628 logfile_top_uint (hex_charset);
6629 logfile_top_uint (hex_salt);
6630 logfile_top_uint (hex_wordlist);
6631 logfile_top_uint (increment);
6632 logfile_top_uint (increment_max);
6633 logfile_top_uint (increment_min);
6634 logfile_top_uint (keyspace);
6635 logfile_top_uint (left);
6636 logfile_top_uint (logfile_disable);
6637 logfile_top_uint (loopback);
6638 logfile_top_uint (markov_classic);
6639 logfile_top_uint (markov_disable);
6640 logfile_top_uint (markov_threshold);
6641 logfile_top_uint (outfile_autohex);
6642 logfile_top_uint (outfile_check_timer);
6643 logfile_top_uint (outfile_format);
6644 logfile_top_uint (potfile_disable);
6645 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6646 logfile_top_uint (powertune_enable);
6647 #endif
6648 logfile_top_uint (scrypt_tmto);
6649 logfile_top_uint (quiet);
6650 logfile_top_uint (remove);
6651 logfile_top_uint (remove_timer);
6652 logfile_top_uint (restore);
6653 logfile_top_uint (restore_disable);
6654 logfile_top_uint (restore_timer);
6655 logfile_top_uint (rp_gen);
6656 logfile_top_uint (rp_gen_func_max);
6657 logfile_top_uint (rp_gen_func_min);
6658 logfile_top_uint (rp_gen_seed);
6659 logfile_top_uint (runtime);
6660 logfile_top_uint (segment_size);
6661 logfile_top_uint (show);
6662 logfile_top_uint (status);
6663 logfile_top_uint (status_automat);
6664 logfile_top_uint (status_timer);
6665 logfile_top_uint (usage);
6666 logfile_top_uint (username);
6667 logfile_top_uint (version);
6668 logfile_top_uint (weak_hash_threshold);
6669 logfile_top_uint (workload_profile);
6670 logfile_top_uint64 (limit);
6671 logfile_top_uint64 (skip);
6672 logfile_top_char (separator);
6673 logfile_top_string (cpu_affinity);
6674 logfile_top_string (custom_charset_1);
6675 logfile_top_string (custom_charset_2);
6676 logfile_top_string (custom_charset_3);
6677 logfile_top_string (custom_charset_4);
6678 logfile_top_string (debug_file);
6679 logfile_top_string (opencl_devices);
6680 logfile_top_string (opencl_platforms);
6681 logfile_top_string (opencl_device_types);
6682 logfile_top_uint (opencl_vector_width);
6683 logfile_top_string (induction_dir);
6684 logfile_top_string (markov_hcstat);
6685 logfile_top_string (outfile);
6686 logfile_top_string (outfile_check_dir);
6687 logfile_top_string (rule_buf_l);
6688 logfile_top_string (rule_buf_r);
6689 logfile_top_string (session);
6690 logfile_top_string (truecrypt_keyfiles);
6691
6692 /**
6693 * Init OpenCL library loader
6694 */
6695
6696 if (keyspace == 0)
6697 {
6698 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6699
6700 ocl_init (ocl);
6701
6702 data.ocl = ocl;
6703 }
6704
6705 /**
6706 * OpenCL platform selection
6707 */
6708
6709 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6710
6711 /**
6712 * OpenCL device selection
6713 */
6714
6715 u32 devices_filter = setup_devices_filter (opencl_devices);
6716
6717 /**
6718 * OpenCL device type selection
6719 */
6720
6721 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6722
6723 /**
6724 * benchmark
6725 */
6726
6727 if (benchmark == 1)
6728 {
6729 /**
6730 * disable useless stuff for benchmark
6731 */
6732
6733 status_timer = 0;
6734 restore_timer = 0;
6735 restore_disable = 1;
6736 potfile_disable = 1;
6737 weak_hash_threshold = 0;
6738 gpu_temp_disable = 1;
6739
6740 data.status_timer = status_timer;
6741 data.restore_timer = restore_timer;
6742 data.restore_disable = restore_disable;
6743
6744 /**
6745 * force attack mode to be bruteforce
6746 */
6747
6748 attack_mode = ATTACK_MODE_BF;
6749 attack_kern = ATTACK_KERN_BF;
6750
6751 if (workload_profile_chgd == 0)
6752 {
6753 workload_profile = 3;
6754
6755 data.workload_profile = workload_profile;
6756 }
6757 }
6758
6759 /**
6760 * config
6761 */
6762
6763 uint hash_type = 0;
6764 uint salt_type = 0;
6765 uint attack_exec = 0;
6766 uint opts_type = 0;
6767 uint kern_type = 0;
6768 uint dgst_size = 0;
6769 uint esalt_size = 0;
6770 uint opti_type = 0;
6771 uint dgst_pos0 = -1;
6772 uint dgst_pos1 = -1;
6773 uint dgst_pos2 = -1;
6774 uint dgst_pos3 = -1;
6775
6776 int (*parse_func) (char *, uint, hash_t *);
6777 int (*sort_by_digest) (const void *, const void *);
6778
6779 uint algorithm_pos = 0;
6780 uint algorithm_max = 1;
6781
6782 uint *algorithms = default_benchmark_algorithms;
6783
6784 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6785
6786 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6787 {
6788 /*
6789 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6790 * the following algos are skipped entirely
6791 */
6792
6793 if (algorithm_pos > 0)
6794 {
6795 local_free (rd);
6796
6797 rd = init_restore (argc, argv);
6798
6799 data.rd = rd;
6800 }
6801
6802 /**
6803 * update hash_mode in case of multihash benchmark
6804 */
6805
6806 if (benchmark == 1)
6807 {
6808 if (hash_mode_chgd == 0)
6809 {
6810 hash_mode = algorithms[algorithm_pos];
6811
6812 data.hash_mode = hash_mode;
6813 }
6814
6815 quiet = 1;
6816
6817 data.quiet = quiet;
6818 }
6819
6820 switch (hash_mode)
6821 {
6822 case 0: hash_type = HASH_TYPE_MD5;
6823 salt_type = SALT_TYPE_NONE;
6824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6825 opts_type = OPTS_TYPE_PT_GENERATE_LE
6826 | OPTS_TYPE_PT_ADD80
6827 | OPTS_TYPE_PT_ADDBITS14;
6828 kern_type = KERN_TYPE_MD5;
6829 dgst_size = DGST_SIZE_4_4;
6830 parse_func = md5_parse_hash;
6831 sort_by_digest = sort_by_digest_4_4;
6832 opti_type = OPTI_TYPE_ZERO_BYTE
6833 | OPTI_TYPE_PRECOMPUTE_INIT
6834 | OPTI_TYPE_PRECOMPUTE_MERKLE
6835 | OPTI_TYPE_MEET_IN_MIDDLE
6836 | OPTI_TYPE_EARLY_SKIP
6837 | OPTI_TYPE_NOT_ITERATED
6838 | OPTI_TYPE_NOT_SALTED
6839 | OPTI_TYPE_RAW_HASH;
6840 dgst_pos0 = 0;
6841 dgst_pos1 = 3;
6842 dgst_pos2 = 2;
6843 dgst_pos3 = 1;
6844 break;
6845
6846 case 10: hash_type = HASH_TYPE_MD5;
6847 salt_type = SALT_TYPE_INTERN;
6848 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6849 opts_type = OPTS_TYPE_PT_GENERATE_LE
6850 | OPTS_TYPE_ST_ADD80
6851 | OPTS_TYPE_ST_ADDBITS14;
6852 kern_type = KERN_TYPE_MD5_PWSLT;
6853 dgst_size = DGST_SIZE_4_4;
6854 parse_func = md5s_parse_hash;
6855 sort_by_digest = sort_by_digest_4_4;
6856 opti_type = OPTI_TYPE_ZERO_BYTE
6857 | OPTI_TYPE_PRECOMPUTE_INIT
6858 | OPTI_TYPE_PRECOMPUTE_MERKLE
6859 | OPTI_TYPE_MEET_IN_MIDDLE
6860 | OPTI_TYPE_EARLY_SKIP
6861 | OPTI_TYPE_NOT_ITERATED
6862 | OPTI_TYPE_APPENDED_SALT
6863 | OPTI_TYPE_RAW_HASH;
6864 dgst_pos0 = 0;
6865 dgst_pos1 = 3;
6866 dgst_pos2 = 2;
6867 dgst_pos3 = 1;
6868 break;
6869
6870 case 11: hash_type = HASH_TYPE_MD5;
6871 salt_type = SALT_TYPE_INTERN;
6872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6873 opts_type = OPTS_TYPE_PT_GENERATE_LE
6874 | OPTS_TYPE_ST_ADD80
6875 | OPTS_TYPE_ST_ADDBITS14;
6876 kern_type = KERN_TYPE_MD5_PWSLT;
6877 dgst_size = DGST_SIZE_4_4;
6878 parse_func = joomla_parse_hash;
6879 sort_by_digest = sort_by_digest_4_4;
6880 opti_type = OPTI_TYPE_ZERO_BYTE
6881 | OPTI_TYPE_PRECOMPUTE_INIT
6882 | OPTI_TYPE_PRECOMPUTE_MERKLE
6883 | OPTI_TYPE_MEET_IN_MIDDLE
6884 | OPTI_TYPE_EARLY_SKIP
6885 | OPTI_TYPE_NOT_ITERATED
6886 | OPTI_TYPE_APPENDED_SALT
6887 | OPTI_TYPE_RAW_HASH;
6888 dgst_pos0 = 0;
6889 dgst_pos1 = 3;
6890 dgst_pos2 = 2;
6891 dgst_pos3 = 1;
6892 break;
6893
6894 case 12: hash_type = HASH_TYPE_MD5;
6895 salt_type = SALT_TYPE_INTERN;
6896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6897 opts_type = OPTS_TYPE_PT_GENERATE_LE
6898 | OPTS_TYPE_ST_ADD80
6899 | OPTS_TYPE_ST_ADDBITS14;
6900 kern_type = KERN_TYPE_MD5_PWSLT;
6901 dgst_size = DGST_SIZE_4_4;
6902 parse_func = postgresql_parse_hash;
6903 sort_by_digest = sort_by_digest_4_4;
6904 opti_type = OPTI_TYPE_ZERO_BYTE
6905 | OPTI_TYPE_PRECOMPUTE_INIT
6906 | OPTI_TYPE_PRECOMPUTE_MERKLE
6907 | OPTI_TYPE_MEET_IN_MIDDLE
6908 | OPTI_TYPE_EARLY_SKIP
6909 | OPTI_TYPE_NOT_ITERATED
6910 | OPTI_TYPE_APPENDED_SALT
6911 | OPTI_TYPE_RAW_HASH;
6912 dgst_pos0 = 0;
6913 dgst_pos1 = 3;
6914 dgst_pos2 = 2;
6915 dgst_pos3 = 1;
6916 break;
6917
6918 case 20: hash_type = HASH_TYPE_MD5;
6919 salt_type = SALT_TYPE_INTERN;
6920 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6921 opts_type = OPTS_TYPE_PT_GENERATE_LE
6922 | OPTS_TYPE_PT_ADD80
6923 | OPTS_TYPE_PT_ADDBITS14;
6924 kern_type = KERN_TYPE_MD5_SLTPW;
6925 dgst_size = DGST_SIZE_4_4;
6926 parse_func = md5s_parse_hash;
6927 sort_by_digest = sort_by_digest_4_4;
6928 opti_type = OPTI_TYPE_ZERO_BYTE
6929 | OPTI_TYPE_PRECOMPUTE_INIT
6930 | OPTI_TYPE_PRECOMPUTE_MERKLE
6931 | OPTI_TYPE_EARLY_SKIP
6932 | OPTI_TYPE_NOT_ITERATED
6933 | OPTI_TYPE_PREPENDED_SALT
6934 | OPTI_TYPE_RAW_HASH;
6935 dgst_pos0 = 0;
6936 dgst_pos1 = 3;
6937 dgst_pos2 = 2;
6938 dgst_pos3 = 1;
6939 break;
6940
6941 case 21: hash_type = HASH_TYPE_MD5;
6942 salt_type = SALT_TYPE_INTERN;
6943 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6944 opts_type = OPTS_TYPE_PT_GENERATE_LE
6945 | OPTS_TYPE_PT_ADD80
6946 | OPTS_TYPE_PT_ADDBITS14;
6947 kern_type = KERN_TYPE_MD5_SLTPW;
6948 dgst_size = DGST_SIZE_4_4;
6949 parse_func = osc_parse_hash;
6950 sort_by_digest = sort_by_digest_4_4;
6951 opti_type = OPTI_TYPE_ZERO_BYTE
6952 | OPTI_TYPE_PRECOMPUTE_INIT
6953 | OPTI_TYPE_PRECOMPUTE_MERKLE
6954 | OPTI_TYPE_EARLY_SKIP
6955 | OPTI_TYPE_NOT_ITERATED
6956 | OPTI_TYPE_PREPENDED_SALT
6957 | OPTI_TYPE_RAW_HASH;
6958 dgst_pos0 = 0;
6959 dgst_pos1 = 3;
6960 dgst_pos2 = 2;
6961 dgst_pos3 = 1;
6962 break;
6963
6964 case 22: hash_type = HASH_TYPE_MD5;
6965 salt_type = SALT_TYPE_EMBEDDED;
6966 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6967 opts_type = OPTS_TYPE_PT_GENERATE_LE
6968 | OPTS_TYPE_PT_ADD80
6969 | OPTS_TYPE_PT_ADDBITS14;
6970 kern_type = KERN_TYPE_MD5_SLTPW;
6971 dgst_size = DGST_SIZE_4_4;
6972 parse_func = netscreen_parse_hash;
6973 sort_by_digest = sort_by_digest_4_4;
6974 opti_type = OPTI_TYPE_ZERO_BYTE
6975 | OPTI_TYPE_PRECOMPUTE_INIT
6976 | OPTI_TYPE_PRECOMPUTE_MERKLE
6977 | OPTI_TYPE_EARLY_SKIP
6978 | OPTI_TYPE_NOT_ITERATED
6979 | OPTI_TYPE_PREPENDED_SALT
6980 | OPTI_TYPE_RAW_HASH;
6981 dgst_pos0 = 0;
6982 dgst_pos1 = 3;
6983 dgst_pos2 = 2;
6984 dgst_pos3 = 1;
6985 break;
6986
6987 case 23: hash_type = HASH_TYPE_MD5;
6988 salt_type = SALT_TYPE_EMBEDDED;
6989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6990 opts_type = OPTS_TYPE_PT_GENERATE_LE
6991 | OPTS_TYPE_PT_ADD80
6992 | OPTS_TYPE_PT_ADDBITS14;
6993 kern_type = KERN_TYPE_MD5_SLTPW;
6994 dgst_size = DGST_SIZE_4_4;
6995 parse_func = skype_parse_hash;
6996 sort_by_digest = sort_by_digest_4_4;
6997 opti_type = OPTI_TYPE_ZERO_BYTE
6998 | OPTI_TYPE_PRECOMPUTE_INIT
6999 | OPTI_TYPE_PRECOMPUTE_MERKLE
7000 | OPTI_TYPE_EARLY_SKIP
7001 | OPTI_TYPE_NOT_ITERATED
7002 | OPTI_TYPE_PREPENDED_SALT
7003 | OPTI_TYPE_RAW_HASH;
7004 dgst_pos0 = 0;
7005 dgst_pos1 = 3;
7006 dgst_pos2 = 2;
7007 dgst_pos3 = 1;
7008 break;
7009
7010 case 30: hash_type = HASH_TYPE_MD5;
7011 salt_type = SALT_TYPE_INTERN;
7012 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7013 opts_type = OPTS_TYPE_PT_GENERATE_LE
7014 | OPTS_TYPE_PT_UNICODE
7015 | OPTS_TYPE_ST_ADD80
7016 | OPTS_TYPE_ST_ADDBITS14;
7017 kern_type = KERN_TYPE_MD5_PWUSLT;
7018 dgst_size = DGST_SIZE_4_4;
7019 parse_func = md5s_parse_hash;
7020 sort_by_digest = sort_by_digest_4_4;
7021 opti_type = OPTI_TYPE_ZERO_BYTE
7022 | OPTI_TYPE_PRECOMPUTE_INIT
7023 | OPTI_TYPE_PRECOMPUTE_MERKLE
7024 | OPTI_TYPE_MEET_IN_MIDDLE
7025 | OPTI_TYPE_EARLY_SKIP
7026 | OPTI_TYPE_NOT_ITERATED
7027 | OPTI_TYPE_APPENDED_SALT
7028 | OPTI_TYPE_RAW_HASH;
7029 dgst_pos0 = 0;
7030 dgst_pos1 = 3;
7031 dgst_pos2 = 2;
7032 dgst_pos3 = 1;
7033 break;
7034
7035 case 40: hash_type = HASH_TYPE_MD5;
7036 salt_type = SALT_TYPE_INTERN;
7037 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7038 opts_type = OPTS_TYPE_PT_GENERATE_LE
7039 | OPTS_TYPE_PT_ADD80
7040 | OPTS_TYPE_PT_ADDBITS14
7041 | OPTS_TYPE_PT_UNICODE;
7042 kern_type = KERN_TYPE_MD5_SLTPWU;
7043 dgst_size = DGST_SIZE_4_4;
7044 parse_func = md5s_parse_hash;
7045 sort_by_digest = sort_by_digest_4_4;
7046 opti_type = OPTI_TYPE_ZERO_BYTE
7047 | OPTI_TYPE_PRECOMPUTE_INIT
7048 | OPTI_TYPE_PRECOMPUTE_MERKLE
7049 | OPTI_TYPE_EARLY_SKIP
7050 | OPTI_TYPE_NOT_ITERATED
7051 | OPTI_TYPE_PREPENDED_SALT
7052 | OPTI_TYPE_RAW_HASH;
7053 dgst_pos0 = 0;
7054 dgst_pos1 = 3;
7055 dgst_pos2 = 2;
7056 dgst_pos3 = 1;
7057 break;
7058
7059 case 50: hash_type = HASH_TYPE_MD5;
7060 salt_type = SALT_TYPE_INTERN;
7061 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7062 opts_type = OPTS_TYPE_PT_GENERATE_LE
7063 | OPTS_TYPE_ST_ADD80
7064 | OPTS_TYPE_ST_ADDBITS14;
7065 kern_type = KERN_TYPE_HMACMD5_PW;
7066 dgst_size = DGST_SIZE_4_4;
7067 parse_func = hmacmd5_parse_hash;
7068 sort_by_digest = sort_by_digest_4_4;
7069 opti_type = OPTI_TYPE_ZERO_BYTE
7070 | OPTI_TYPE_NOT_ITERATED;
7071 dgst_pos0 = 0;
7072 dgst_pos1 = 3;
7073 dgst_pos2 = 2;
7074 dgst_pos3 = 1;
7075 break;
7076
7077 case 60: hash_type = HASH_TYPE_MD5;
7078 salt_type = SALT_TYPE_INTERN;
7079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7080 opts_type = OPTS_TYPE_PT_GENERATE_LE
7081 | OPTS_TYPE_PT_ADD80
7082 | OPTS_TYPE_PT_ADDBITS14;
7083 kern_type = KERN_TYPE_HMACMD5_SLT;
7084 dgst_size = DGST_SIZE_4_4;
7085 parse_func = hmacmd5_parse_hash;
7086 sort_by_digest = sort_by_digest_4_4;
7087 opti_type = OPTI_TYPE_ZERO_BYTE
7088 | OPTI_TYPE_NOT_ITERATED;
7089 dgst_pos0 = 0;
7090 dgst_pos1 = 3;
7091 dgst_pos2 = 2;
7092 dgst_pos3 = 1;
7093 break;
7094
7095 case 100: hash_type = HASH_TYPE_SHA1;
7096 salt_type = SALT_TYPE_NONE;
7097 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7098 opts_type = OPTS_TYPE_PT_GENERATE_BE
7099 | OPTS_TYPE_PT_ADD80
7100 | OPTS_TYPE_PT_ADDBITS15;
7101 kern_type = KERN_TYPE_SHA1;
7102 dgst_size = DGST_SIZE_4_5;
7103 parse_func = sha1_parse_hash;
7104 sort_by_digest = sort_by_digest_4_5;
7105 opti_type = OPTI_TYPE_ZERO_BYTE
7106 | OPTI_TYPE_PRECOMPUTE_INIT
7107 | OPTI_TYPE_PRECOMPUTE_MERKLE
7108 | OPTI_TYPE_EARLY_SKIP
7109 | OPTI_TYPE_NOT_ITERATED
7110 | OPTI_TYPE_NOT_SALTED
7111 | OPTI_TYPE_RAW_HASH;
7112 dgst_pos0 = 3;
7113 dgst_pos1 = 4;
7114 dgst_pos2 = 2;
7115 dgst_pos3 = 1;
7116 break;
7117
7118 case 101: hash_type = HASH_TYPE_SHA1;
7119 salt_type = SALT_TYPE_NONE;
7120 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7121 opts_type = OPTS_TYPE_PT_GENERATE_BE
7122 | OPTS_TYPE_PT_ADD80
7123 | OPTS_TYPE_PT_ADDBITS15;
7124 kern_type = KERN_TYPE_SHA1;
7125 dgst_size = DGST_SIZE_4_5;
7126 parse_func = sha1b64_parse_hash;
7127 sort_by_digest = sort_by_digest_4_5;
7128 opti_type = OPTI_TYPE_ZERO_BYTE
7129 | OPTI_TYPE_PRECOMPUTE_INIT
7130 | OPTI_TYPE_PRECOMPUTE_MERKLE
7131 | OPTI_TYPE_EARLY_SKIP
7132 | OPTI_TYPE_NOT_ITERATED
7133 | OPTI_TYPE_NOT_SALTED
7134 | OPTI_TYPE_RAW_HASH;
7135 dgst_pos0 = 3;
7136 dgst_pos1 = 4;
7137 dgst_pos2 = 2;
7138 dgst_pos3 = 1;
7139 break;
7140
7141 case 110: hash_type = HASH_TYPE_SHA1;
7142 salt_type = SALT_TYPE_INTERN;
7143 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7144 opts_type = OPTS_TYPE_PT_GENERATE_BE
7145 | OPTS_TYPE_ST_ADD80
7146 | OPTS_TYPE_ST_ADDBITS15;
7147 kern_type = KERN_TYPE_SHA1_PWSLT;
7148 dgst_size = DGST_SIZE_4_5;
7149 parse_func = sha1s_parse_hash;
7150 sort_by_digest = sort_by_digest_4_5;
7151 opti_type = OPTI_TYPE_ZERO_BYTE
7152 | OPTI_TYPE_PRECOMPUTE_INIT
7153 | OPTI_TYPE_PRECOMPUTE_MERKLE
7154 | OPTI_TYPE_EARLY_SKIP
7155 | OPTI_TYPE_NOT_ITERATED
7156 | OPTI_TYPE_APPENDED_SALT
7157 | OPTI_TYPE_RAW_HASH;
7158 dgst_pos0 = 3;
7159 dgst_pos1 = 4;
7160 dgst_pos2 = 2;
7161 dgst_pos3 = 1;
7162 break;
7163
7164 case 111: hash_type = HASH_TYPE_SHA1;
7165 salt_type = SALT_TYPE_EMBEDDED;
7166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7167 opts_type = OPTS_TYPE_PT_GENERATE_BE
7168 | OPTS_TYPE_ST_ADD80
7169 | OPTS_TYPE_ST_ADDBITS15;
7170 kern_type = KERN_TYPE_SHA1_PWSLT;
7171 dgst_size = DGST_SIZE_4_5;
7172 parse_func = sha1b64s_parse_hash;
7173 sort_by_digest = sort_by_digest_4_5;
7174 opti_type = OPTI_TYPE_ZERO_BYTE
7175 | OPTI_TYPE_PRECOMPUTE_INIT
7176 | OPTI_TYPE_PRECOMPUTE_MERKLE
7177 | OPTI_TYPE_EARLY_SKIP
7178 | OPTI_TYPE_NOT_ITERATED
7179 | OPTI_TYPE_APPENDED_SALT
7180 | OPTI_TYPE_RAW_HASH;
7181 dgst_pos0 = 3;
7182 dgst_pos1 = 4;
7183 dgst_pos2 = 2;
7184 dgst_pos3 = 1;
7185 break;
7186
7187 case 112: hash_type = HASH_TYPE_SHA1;
7188 salt_type = SALT_TYPE_INTERN;
7189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7190 opts_type = OPTS_TYPE_PT_GENERATE_BE
7191 | OPTS_TYPE_ST_ADD80
7192 | OPTS_TYPE_ST_ADDBITS15
7193 | OPTS_TYPE_ST_HEX;
7194 kern_type = KERN_TYPE_SHA1_PWSLT;
7195 dgst_size = DGST_SIZE_4_5;
7196 parse_func = oracles_parse_hash;
7197 sort_by_digest = sort_by_digest_4_5;
7198 opti_type = OPTI_TYPE_ZERO_BYTE
7199 | OPTI_TYPE_PRECOMPUTE_INIT
7200 | OPTI_TYPE_PRECOMPUTE_MERKLE
7201 | OPTI_TYPE_EARLY_SKIP
7202 | OPTI_TYPE_NOT_ITERATED
7203 | OPTI_TYPE_APPENDED_SALT
7204 | OPTI_TYPE_RAW_HASH;
7205 dgst_pos0 = 3;
7206 dgst_pos1 = 4;
7207 dgst_pos2 = 2;
7208 dgst_pos3 = 1;
7209 break;
7210
7211 case 120: hash_type = HASH_TYPE_SHA1;
7212 salt_type = SALT_TYPE_INTERN;
7213 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7214 opts_type = OPTS_TYPE_PT_GENERATE_BE
7215 | OPTS_TYPE_PT_ADD80
7216 | OPTS_TYPE_PT_ADDBITS15;
7217 kern_type = KERN_TYPE_SHA1_SLTPW;
7218 dgst_size = DGST_SIZE_4_5;
7219 parse_func = sha1s_parse_hash;
7220 sort_by_digest = sort_by_digest_4_5;
7221 opti_type = OPTI_TYPE_ZERO_BYTE
7222 | OPTI_TYPE_PRECOMPUTE_INIT
7223 | OPTI_TYPE_PRECOMPUTE_MERKLE
7224 | OPTI_TYPE_EARLY_SKIP
7225 | OPTI_TYPE_NOT_ITERATED
7226 | OPTI_TYPE_PREPENDED_SALT
7227 | OPTI_TYPE_RAW_HASH;
7228 dgst_pos0 = 3;
7229 dgst_pos1 = 4;
7230 dgst_pos2 = 2;
7231 dgst_pos3 = 1;
7232 break;
7233
7234 case 121: hash_type = HASH_TYPE_SHA1;
7235 salt_type = SALT_TYPE_INTERN;
7236 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7237 opts_type = OPTS_TYPE_PT_GENERATE_BE
7238 | OPTS_TYPE_PT_ADD80
7239 | OPTS_TYPE_PT_ADDBITS15
7240 | OPTS_TYPE_ST_LOWER;
7241 kern_type = KERN_TYPE_SHA1_SLTPW;
7242 dgst_size = DGST_SIZE_4_5;
7243 parse_func = smf_parse_hash;
7244 sort_by_digest = sort_by_digest_4_5;
7245 opti_type = OPTI_TYPE_ZERO_BYTE
7246 | OPTI_TYPE_PRECOMPUTE_INIT
7247 | OPTI_TYPE_PRECOMPUTE_MERKLE
7248 | OPTI_TYPE_EARLY_SKIP
7249 | OPTI_TYPE_NOT_ITERATED
7250 | OPTI_TYPE_PREPENDED_SALT
7251 | OPTI_TYPE_RAW_HASH;
7252 dgst_pos0 = 3;
7253 dgst_pos1 = 4;
7254 dgst_pos2 = 2;
7255 dgst_pos3 = 1;
7256 break;
7257
7258 case 122: hash_type = HASH_TYPE_SHA1;
7259 salt_type = SALT_TYPE_EMBEDDED;
7260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7261 opts_type = OPTS_TYPE_PT_GENERATE_BE
7262 | OPTS_TYPE_PT_ADD80
7263 | OPTS_TYPE_PT_ADDBITS15
7264 | OPTS_TYPE_ST_HEX;
7265 kern_type = KERN_TYPE_SHA1_SLTPW;
7266 dgst_size = DGST_SIZE_4_5;
7267 parse_func = osx1_parse_hash;
7268 sort_by_digest = sort_by_digest_4_5;
7269 opti_type = OPTI_TYPE_ZERO_BYTE
7270 | OPTI_TYPE_PRECOMPUTE_INIT
7271 | OPTI_TYPE_PRECOMPUTE_MERKLE
7272 | OPTI_TYPE_EARLY_SKIP
7273 | OPTI_TYPE_NOT_ITERATED
7274 | OPTI_TYPE_PREPENDED_SALT
7275 | OPTI_TYPE_RAW_HASH;
7276 dgst_pos0 = 3;
7277 dgst_pos1 = 4;
7278 dgst_pos2 = 2;
7279 dgst_pos3 = 1;
7280 break;
7281
7282 case 124: hash_type = HASH_TYPE_SHA1;
7283 salt_type = SALT_TYPE_EMBEDDED;
7284 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7285 opts_type = OPTS_TYPE_PT_GENERATE_BE
7286 | OPTS_TYPE_PT_ADD80
7287 | OPTS_TYPE_PT_ADDBITS15;
7288 kern_type = KERN_TYPE_SHA1_SLTPW;
7289 dgst_size = DGST_SIZE_4_5;
7290 parse_func = djangosha1_parse_hash;
7291 sort_by_digest = sort_by_digest_4_5;
7292 opti_type = OPTI_TYPE_ZERO_BYTE
7293 | OPTI_TYPE_PRECOMPUTE_INIT
7294 | OPTI_TYPE_PRECOMPUTE_MERKLE
7295 | OPTI_TYPE_EARLY_SKIP
7296 | OPTI_TYPE_NOT_ITERATED
7297 | OPTI_TYPE_PREPENDED_SALT
7298 | OPTI_TYPE_RAW_HASH;
7299 dgst_pos0 = 3;
7300 dgst_pos1 = 4;
7301 dgst_pos2 = 2;
7302 dgst_pos3 = 1;
7303 break;
7304
7305 case 130: hash_type = HASH_TYPE_SHA1;
7306 salt_type = SALT_TYPE_INTERN;
7307 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7308 opts_type = OPTS_TYPE_PT_GENERATE_BE
7309 | OPTS_TYPE_PT_UNICODE
7310 | OPTS_TYPE_ST_ADD80
7311 | OPTS_TYPE_ST_ADDBITS15;
7312 kern_type = KERN_TYPE_SHA1_PWUSLT;
7313 dgst_size = DGST_SIZE_4_5;
7314 parse_func = sha1s_parse_hash;
7315 sort_by_digest = sort_by_digest_4_5;
7316 opti_type = OPTI_TYPE_ZERO_BYTE
7317 | OPTI_TYPE_PRECOMPUTE_INIT
7318 | OPTI_TYPE_PRECOMPUTE_MERKLE
7319 | OPTI_TYPE_EARLY_SKIP
7320 | OPTI_TYPE_NOT_ITERATED
7321 | OPTI_TYPE_APPENDED_SALT
7322 | OPTI_TYPE_RAW_HASH;
7323 dgst_pos0 = 3;
7324 dgst_pos1 = 4;
7325 dgst_pos2 = 2;
7326 dgst_pos3 = 1;
7327 break;
7328
7329 case 131: hash_type = HASH_TYPE_SHA1;
7330 salt_type = SALT_TYPE_EMBEDDED;
7331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7332 opts_type = OPTS_TYPE_PT_GENERATE_BE
7333 | OPTS_TYPE_PT_UNICODE
7334 | OPTS_TYPE_PT_UPPER
7335 | OPTS_TYPE_ST_ADD80
7336 | OPTS_TYPE_ST_ADDBITS15
7337 | OPTS_TYPE_ST_HEX;
7338 kern_type = KERN_TYPE_SHA1_PWUSLT;
7339 dgst_size = DGST_SIZE_4_5;
7340 parse_func = mssql2000_parse_hash;
7341 sort_by_digest = sort_by_digest_4_5;
7342 opti_type = OPTI_TYPE_ZERO_BYTE
7343 | OPTI_TYPE_PRECOMPUTE_INIT
7344 | OPTI_TYPE_PRECOMPUTE_MERKLE
7345 | OPTI_TYPE_EARLY_SKIP
7346 | OPTI_TYPE_NOT_ITERATED
7347 | OPTI_TYPE_APPENDED_SALT
7348 | OPTI_TYPE_RAW_HASH;
7349 dgst_pos0 = 3;
7350 dgst_pos1 = 4;
7351 dgst_pos2 = 2;
7352 dgst_pos3 = 1;
7353 break;
7354
7355 case 132: hash_type = HASH_TYPE_SHA1;
7356 salt_type = SALT_TYPE_EMBEDDED;
7357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7358 opts_type = OPTS_TYPE_PT_GENERATE_BE
7359 | OPTS_TYPE_PT_UNICODE
7360 | OPTS_TYPE_ST_ADD80
7361 | OPTS_TYPE_ST_ADDBITS15
7362 | OPTS_TYPE_ST_HEX;
7363 kern_type = KERN_TYPE_SHA1_PWUSLT;
7364 dgst_size = DGST_SIZE_4_5;
7365 parse_func = mssql2005_parse_hash;
7366 sort_by_digest = sort_by_digest_4_5;
7367 opti_type = OPTI_TYPE_ZERO_BYTE
7368 | OPTI_TYPE_PRECOMPUTE_INIT
7369 | OPTI_TYPE_PRECOMPUTE_MERKLE
7370 | OPTI_TYPE_EARLY_SKIP
7371 | OPTI_TYPE_NOT_ITERATED
7372 | OPTI_TYPE_APPENDED_SALT
7373 | OPTI_TYPE_RAW_HASH;
7374 dgst_pos0 = 3;
7375 dgst_pos1 = 4;
7376 dgst_pos2 = 2;
7377 dgst_pos3 = 1;
7378 break;
7379
7380 case 133: hash_type = HASH_TYPE_SHA1;
7381 salt_type = SALT_TYPE_EMBEDDED;
7382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7383 opts_type = OPTS_TYPE_PT_GENERATE_BE
7384 | OPTS_TYPE_PT_UNICODE
7385 | OPTS_TYPE_ST_ADD80
7386 | OPTS_TYPE_ST_ADDBITS15;
7387 kern_type = KERN_TYPE_SHA1_PWUSLT;
7388 dgst_size = DGST_SIZE_4_5;
7389 parse_func = peoplesoft_parse_hash;
7390 sort_by_digest = sort_by_digest_4_5;
7391 opti_type = OPTI_TYPE_ZERO_BYTE
7392 | OPTI_TYPE_PRECOMPUTE_INIT
7393 | OPTI_TYPE_PRECOMPUTE_MERKLE
7394 | OPTI_TYPE_EARLY_SKIP
7395 | OPTI_TYPE_NOT_ITERATED
7396 | OPTI_TYPE_APPENDED_SALT
7397 | OPTI_TYPE_RAW_HASH;
7398 dgst_pos0 = 3;
7399 dgst_pos1 = 4;
7400 dgst_pos2 = 2;
7401 dgst_pos3 = 1;
7402 break;
7403
7404 case 140: hash_type = HASH_TYPE_SHA1;
7405 salt_type = SALT_TYPE_INTERN;
7406 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7407 opts_type = OPTS_TYPE_PT_GENERATE_BE
7408 | OPTS_TYPE_PT_ADD80
7409 | OPTS_TYPE_PT_ADDBITS15
7410 | OPTS_TYPE_PT_UNICODE;
7411 kern_type = KERN_TYPE_SHA1_SLTPWU;
7412 dgst_size = DGST_SIZE_4_5;
7413 parse_func = sha1s_parse_hash;
7414 sort_by_digest = sort_by_digest_4_5;
7415 opti_type = OPTI_TYPE_ZERO_BYTE
7416 | OPTI_TYPE_PRECOMPUTE_INIT
7417 | OPTI_TYPE_PRECOMPUTE_MERKLE
7418 | OPTI_TYPE_EARLY_SKIP
7419 | OPTI_TYPE_NOT_ITERATED
7420 | OPTI_TYPE_PREPENDED_SALT
7421 | OPTI_TYPE_RAW_HASH;
7422 dgst_pos0 = 3;
7423 dgst_pos1 = 4;
7424 dgst_pos2 = 2;
7425 dgst_pos3 = 1;
7426 break;
7427
7428 case 141: hash_type = HASH_TYPE_SHA1;
7429 salt_type = SALT_TYPE_EMBEDDED;
7430 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7431 opts_type = OPTS_TYPE_PT_GENERATE_BE
7432 | OPTS_TYPE_PT_ADD80
7433 | OPTS_TYPE_PT_ADDBITS15
7434 | OPTS_TYPE_PT_UNICODE
7435 | OPTS_TYPE_ST_BASE64;
7436 kern_type = KERN_TYPE_SHA1_SLTPWU;
7437 dgst_size = DGST_SIZE_4_5;
7438 parse_func = episerver_parse_hash;
7439 sort_by_digest = sort_by_digest_4_5;
7440 opti_type = OPTI_TYPE_ZERO_BYTE
7441 | OPTI_TYPE_PRECOMPUTE_INIT
7442 | OPTI_TYPE_PRECOMPUTE_MERKLE
7443 | OPTI_TYPE_EARLY_SKIP
7444 | OPTI_TYPE_NOT_ITERATED
7445 | OPTI_TYPE_PREPENDED_SALT
7446 | OPTI_TYPE_RAW_HASH;
7447 dgst_pos0 = 3;
7448 dgst_pos1 = 4;
7449 dgst_pos2 = 2;
7450 dgst_pos3 = 1;
7451 break;
7452
7453 case 150: hash_type = HASH_TYPE_SHA1;
7454 salt_type = SALT_TYPE_INTERN;
7455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7456 opts_type = OPTS_TYPE_PT_GENERATE_BE
7457 | OPTS_TYPE_ST_ADD80
7458 | OPTS_TYPE_ST_ADDBITS15;
7459 kern_type = KERN_TYPE_HMACSHA1_PW;
7460 dgst_size = DGST_SIZE_4_5;
7461 parse_func = hmacsha1_parse_hash;
7462 sort_by_digest = sort_by_digest_4_5;
7463 opti_type = OPTI_TYPE_ZERO_BYTE
7464 | OPTI_TYPE_NOT_ITERATED;
7465 dgst_pos0 = 3;
7466 dgst_pos1 = 4;
7467 dgst_pos2 = 2;
7468 dgst_pos3 = 1;
7469 break;
7470
7471 case 160: hash_type = HASH_TYPE_SHA1;
7472 salt_type = SALT_TYPE_INTERN;
7473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7474 opts_type = OPTS_TYPE_PT_GENERATE_BE
7475 | OPTS_TYPE_PT_ADD80
7476 | OPTS_TYPE_PT_ADDBITS15;
7477 kern_type = KERN_TYPE_HMACSHA1_SLT;
7478 dgst_size = DGST_SIZE_4_5;
7479 parse_func = hmacsha1_parse_hash;
7480 sort_by_digest = sort_by_digest_4_5;
7481 opti_type = OPTI_TYPE_ZERO_BYTE
7482 | OPTI_TYPE_NOT_ITERATED;
7483 dgst_pos0 = 3;
7484 dgst_pos1 = 4;
7485 dgst_pos2 = 2;
7486 dgst_pos3 = 1;
7487 break;
7488
7489 case 190: hash_type = HASH_TYPE_SHA1;
7490 salt_type = SALT_TYPE_NONE;
7491 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7492 opts_type = OPTS_TYPE_PT_GENERATE_BE
7493 | OPTS_TYPE_PT_ADD80
7494 | OPTS_TYPE_PT_ADDBITS15;
7495 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7496 dgst_size = DGST_SIZE_4_5;
7497 parse_func = sha1linkedin_parse_hash;
7498 sort_by_digest = sort_by_digest_4_5;
7499 opti_type = OPTI_TYPE_ZERO_BYTE
7500 | OPTI_TYPE_PRECOMPUTE_INIT
7501 | OPTI_TYPE_EARLY_SKIP
7502 | OPTI_TYPE_NOT_ITERATED
7503 | OPTI_TYPE_NOT_SALTED;
7504 dgst_pos0 = 0;
7505 dgst_pos1 = 4;
7506 dgst_pos2 = 3;
7507 dgst_pos3 = 2;
7508 break;
7509
7510 case 200: hash_type = HASH_TYPE_MYSQL;
7511 salt_type = SALT_TYPE_NONE;
7512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7513 opts_type = 0;
7514 kern_type = KERN_TYPE_MYSQL;
7515 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7516 parse_func = mysql323_parse_hash;
7517 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7518 opti_type = OPTI_TYPE_ZERO_BYTE;
7519 dgst_pos0 = 0;
7520 dgst_pos1 = 1;
7521 dgst_pos2 = 2;
7522 dgst_pos3 = 3;
7523 break;
7524
7525 case 300: hash_type = HASH_TYPE_SHA1;
7526 salt_type = SALT_TYPE_NONE;
7527 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7528 opts_type = OPTS_TYPE_PT_GENERATE_BE
7529 | OPTS_TYPE_PT_ADD80
7530 | OPTS_TYPE_PT_ADDBITS15;
7531 kern_type = KERN_TYPE_MYSQL41;
7532 dgst_size = DGST_SIZE_4_5;
7533 parse_func = sha1_parse_hash;
7534 sort_by_digest = sort_by_digest_4_5;
7535 opti_type = OPTI_TYPE_ZERO_BYTE
7536 | OPTI_TYPE_PRECOMPUTE_INIT
7537 | OPTI_TYPE_PRECOMPUTE_MERKLE
7538 | OPTI_TYPE_EARLY_SKIP
7539 | OPTI_TYPE_NOT_ITERATED
7540 | OPTI_TYPE_NOT_SALTED;
7541 dgst_pos0 = 3;
7542 dgst_pos1 = 4;
7543 dgst_pos2 = 2;
7544 dgst_pos3 = 1;
7545 break;
7546
7547 case 400: hash_type = HASH_TYPE_MD5;
7548 salt_type = SALT_TYPE_EMBEDDED;
7549 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7550 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7551 kern_type = KERN_TYPE_PHPASS;
7552 dgst_size = DGST_SIZE_4_4;
7553 parse_func = phpass_parse_hash;
7554 sort_by_digest = sort_by_digest_4_4;
7555 opti_type = OPTI_TYPE_ZERO_BYTE;
7556 dgst_pos0 = 0;
7557 dgst_pos1 = 1;
7558 dgst_pos2 = 2;
7559 dgst_pos3 = 3;
7560 break;
7561
7562 case 500: hash_type = HASH_TYPE_MD5;
7563 salt_type = SALT_TYPE_EMBEDDED;
7564 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7565 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7566 kern_type = KERN_TYPE_MD5CRYPT;
7567 dgst_size = DGST_SIZE_4_4;
7568 parse_func = md5crypt_parse_hash;
7569 sort_by_digest = sort_by_digest_4_4;
7570 opti_type = OPTI_TYPE_ZERO_BYTE;
7571 dgst_pos0 = 0;
7572 dgst_pos1 = 1;
7573 dgst_pos2 = 2;
7574 dgst_pos3 = 3;
7575 break;
7576
7577 case 501: hash_type = HASH_TYPE_MD5;
7578 salt_type = SALT_TYPE_EMBEDDED;
7579 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7580 opts_type = OPTS_TYPE_PT_GENERATE_LE
7581 | OPTS_TYPE_HASH_COPY;
7582 kern_type = KERN_TYPE_MD5CRYPT;
7583 dgst_size = DGST_SIZE_4_4;
7584 parse_func = juniper_parse_hash;
7585 sort_by_digest = sort_by_digest_4_4;
7586 opti_type = OPTI_TYPE_ZERO_BYTE;
7587 dgst_pos0 = 0;
7588 dgst_pos1 = 1;
7589 dgst_pos2 = 2;
7590 dgst_pos3 = 3;
7591 break;
7592
7593 case 900: hash_type = HASH_TYPE_MD4;
7594 salt_type = SALT_TYPE_NONE;
7595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7596 opts_type = OPTS_TYPE_PT_GENERATE_LE
7597 | OPTS_TYPE_PT_ADD80
7598 | OPTS_TYPE_PT_ADDBITS14;
7599 kern_type = KERN_TYPE_MD4;
7600 dgst_size = DGST_SIZE_4_4;
7601 parse_func = md4_parse_hash;
7602 sort_by_digest = sort_by_digest_4_4;
7603 opti_type = OPTI_TYPE_ZERO_BYTE
7604 | OPTI_TYPE_PRECOMPUTE_INIT
7605 | OPTI_TYPE_PRECOMPUTE_MERKLE
7606 | OPTI_TYPE_MEET_IN_MIDDLE
7607 | OPTI_TYPE_EARLY_SKIP
7608 | OPTI_TYPE_NOT_ITERATED
7609 | OPTI_TYPE_NOT_SALTED
7610 | OPTI_TYPE_RAW_HASH;
7611 dgst_pos0 = 0;
7612 dgst_pos1 = 3;
7613 dgst_pos2 = 2;
7614 dgst_pos3 = 1;
7615 break;
7616
7617 case 1000: hash_type = HASH_TYPE_MD4;
7618 salt_type = SALT_TYPE_NONE;
7619 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7620 opts_type = OPTS_TYPE_PT_GENERATE_LE
7621 | OPTS_TYPE_PT_ADD80
7622 | OPTS_TYPE_PT_ADDBITS14
7623 | OPTS_TYPE_PT_UNICODE;
7624 kern_type = KERN_TYPE_MD4_PWU;
7625 dgst_size = DGST_SIZE_4_4;
7626 parse_func = md4_parse_hash;
7627 sort_by_digest = sort_by_digest_4_4;
7628 opti_type = OPTI_TYPE_ZERO_BYTE
7629 | OPTI_TYPE_PRECOMPUTE_INIT
7630 | OPTI_TYPE_PRECOMPUTE_MERKLE
7631 | OPTI_TYPE_MEET_IN_MIDDLE
7632 | OPTI_TYPE_EARLY_SKIP
7633 | OPTI_TYPE_NOT_ITERATED
7634 | OPTI_TYPE_NOT_SALTED
7635 | OPTI_TYPE_RAW_HASH;
7636 dgst_pos0 = 0;
7637 dgst_pos1 = 3;
7638 dgst_pos2 = 2;
7639 dgst_pos3 = 1;
7640 break;
7641
7642 case 1100: hash_type = HASH_TYPE_MD4;
7643 salt_type = SALT_TYPE_INTERN;
7644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7645 opts_type = OPTS_TYPE_PT_GENERATE_LE
7646 | OPTS_TYPE_PT_ADD80
7647 | OPTS_TYPE_PT_ADDBITS14
7648 | OPTS_TYPE_PT_UNICODE
7649 | OPTS_TYPE_ST_ADD80
7650 | OPTS_TYPE_ST_UNICODE
7651 | OPTS_TYPE_ST_LOWER;
7652 kern_type = KERN_TYPE_MD44_PWUSLT;
7653 dgst_size = DGST_SIZE_4_4;
7654 parse_func = dcc_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_EARLY_SKIP
7660 | OPTI_TYPE_NOT_ITERATED;
7661 dgst_pos0 = 0;
7662 dgst_pos1 = 3;
7663 dgst_pos2 = 2;
7664 dgst_pos3 = 1;
7665 break;
7666
7667 case 1400: hash_type = HASH_TYPE_SHA256;
7668 salt_type = SALT_TYPE_NONE;
7669 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7670 opts_type = OPTS_TYPE_PT_GENERATE_BE
7671 | OPTS_TYPE_PT_ADD80
7672 | OPTS_TYPE_PT_ADDBITS15;
7673 kern_type = KERN_TYPE_SHA256;
7674 dgst_size = DGST_SIZE_4_8;
7675 parse_func = sha256_parse_hash;
7676 sort_by_digest = sort_by_digest_4_8;
7677 opti_type = OPTI_TYPE_ZERO_BYTE
7678 | OPTI_TYPE_PRECOMPUTE_INIT
7679 | OPTI_TYPE_PRECOMPUTE_MERKLE
7680 | OPTI_TYPE_EARLY_SKIP
7681 | OPTI_TYPE_NOT_ITERATED
7682 | OPTI_TYPE_NOT_SALTED
7683 | OPTI_TYPE_RAW_HASH;
7684 dgst_pos0 = 3;
7685 dgst_pos1 = 7;
7686 dgst_pos2 = 2;
7687 dgst_pos3 = 6;
7688 break;
7689
7690 case 1410: hash_type = HASH_TYPE_SHA256;
7691 salt_type = SALT_TYPE_INTERN;
7692 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7693 opts_type = OPTS_TYPE_PT_GENERATE_BE
7694 | OPTS_TYPE_ST_ADD80
7695 | OPTS_TYPE_ST_ADDBITS15;
7696 kern_type = KERN_TYPE_SHA256_PWSLT;
7697 dgst_size = DGST_SIZE_4_8;
7698 parse_func = sha256s_parse_hash;
7699 sort_by_digest = sort_by_digest_4_8;
7700 opti_type = OPTI_TYPE_ZERO_BYTE
7701 | OPTI_TYPE_PRECOMPUTE_INIT
7702 | OPTI_TYPE_PRECOMPUTE_MERKLE
7703 | OPTI_TYPE_EARLY_SKIP
7704 | OPTI_TYPE_NOT_ITERATED
7705 | OPTI_TYPE_APPENDED_SALT
7706 | OPTI_TYPE_RAW_HASH;
7707 dgst_pos0 = 3;
7708 dgst_pos1 = 7;
7709 dgst_pos2 = 2;
7710 dgst_pos3 = 6;
7711 break;
7712
7713 case 1420: hash_type = HASH_TYPE_SHA256;
7714 salt_type = SALT_TYPE_INTERN;
7715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7716 opts_type = OPTS_TYPE_PT_GENERATE_BE
7717 | OPTS_TYPE_PT_ADD80
7718 | OPTS_TYPE_PT_ADDBITS15;
7719 kern_type = KERN_TYPE_SHA256_SLTPW;
7720 dgst_size = DGST_SIZE_4_8;
7721 parse_func = sha256s_parse_hash;
7722 sort_by_digest = sort_by_digest_4_8;
7723 opti_type = OPTI_TYPE_ZERO_BYTE
7724 | OPTI_TYPE_PRECOMPUTE_INIT
7725 | OPTI_TYPE_PRECOMPUTE_MERKLE
7726 | OPTI_TYPE_EARLY_SKIP
7727 | OPTI_TYPE_NOT_ITERATED
7728 | OPTI_TYPE_PREPENDED_SALT
7729 | OPTI_TYPE_RAW_HASH;
7730 dgst_pos0 = 3;
7731 dgst_pos1 = 7;
7732 dgst_pos2 = 2;
7733 dgst_pos3 = 6;
7734 break;
7735
7736 case 1421: hash_type = HASH_TYPE_SHA256;
7737 salt_type = SALT_TYPE_EMBEDDED;
7738 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7739 opts_type = OPTS_TYPE_PT_GENERATE_BE
7740 | OPTS_TYPE_PT_ADD80
7741 | OPTS_TYPE_PT_ADDBITS15;
7742 kern_type = KERN_TYPE_SHA256_SLTPW;
7743 dgst_size = DGST_SIZE_4_8;
7744 parse_func = hmailserver_parse_hash;
7745 sort_by_digest = sort_by_digest_4_8;
7746 opti_type = OPTI_TYPE_ZERO_BYTE
7747 | OPTI_TYPE_PRECOMPUTE_INIT
7748 | OPTI_TYPE_PRECOMPUTE_MERKLE
7749 | OPTI_TYPE_EARLY_SKIP
7750 | OPTI_TYPE_NOT_ITERATED
7751 | OPTI_TYPE_PREPENDED_SALT
7752 | OPTI_TYPE_RAW_HASH;
7753 dgst_pos0 = 3;
7754 dgst_pos1 = 7;
7755 dgst_pos2 = 2;
7756 dgst_pos3 = 6;
7757 break;
7758
7759 case 1430: hash_type = HASH_TYPE_SHA256;
7760 salt_type = SALT_TYPE_INTERN;
7761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7762 opts_type = OPTS_TYPE_PT_GENERATE_BE
7763 | OPTS_TYPE_PT_UNICODE
7764 | OPTS_TYPE_ST_ADD80
7765 | OPTS_TYPE_ST_ADDBITS15;
7766 kern_type = KERN_TYPE_SHA256_PWUSLT;
7767 dgst_size = DGST_SIZE_4_8;
7768 parse_func = sha256s_parse_hash;
7769 sort_by_digest = sort_by_digest_4_8;
7770 opti_type = OPTI_TYPE_ZERO_BYTE
7771 | OPTI_TYPE_PRECOMPUTE_INIT
7772 | OPTI_TYPE_PRECOMPUTE_MERKLE
7773 | OPTI_TYPE_EARLY_SKIP
7774 | OPTI_TYPE_NOT_ITERATED
7775 | OPTI_TYPE_APPENDED_SALT
7776 | OPTI_TYPE_RAW_HASH;
7777 dgst_pos0 = 3;
7778 dgst_pos1 = 7;
7779 dgst_pos2 = 2;
7780 dgst_pos3 = 6;
7781 break;
7782
7783 case 1440: hash_type = HASH_TYPE_SHA256;
7784 salt_type = SALT_TYPE_INTERN;
7785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7786 opts_type = OPTS_TYPE_PT_GENERATE_BE
7787 | OPTS_TYPE_PT_ADD80
7788 | OPTS_TYPE_PT_ADDBITS15
7789 | OPTS_TYPE_PT_UNICODE;
7790 kern_type = KERN_TYPE_SHA256_SLTPWU;
7791 dgst_size = DGST_SIZE_4_8;
7792 parse_func = sha256s_parse_hash;
7793 sort_by_digest = sort_by_digest_4_8;
7794 opti_type = OPTI_TYPE_ZERO_BYTE
7795 | OPTI_TYPE_PRECOMPUTE_INIT
7796 | OPTI_TYPE_PRECOMPUTE_MERKLE
7797 | OPTI_TYPE_EARLY_SKIP
7798 | OPTI_TYPE_NOT_ITERATED
7799 | OPTI_TYPE_PREPENDED_SALT
7800 | OPTI_TYPE_RAW_HASH;
7801 dgst_pos0 = 3;
7802 dgst_pos1 = 7;
7803 dgst_pos2 = 2;
7804 dgst_pos3 = 6;
7805 break;
7806
7807 case 1441: hash_type = HASH_TYPE_SHA256;
7808 salt_type = SALT_TYPE_EMBEDDED;
7809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7810 opts_type = OPTS_TYPE_PT_GENERATE_BE
7811 | OPTS_TYPE_PT_ADD80
7812 | OPTS_TYPE_PT_ADDBITS15
7813 | OPTS_TYPE_PT_UNICODE
7814 | OPTS_TYPE_ST_BASE64;
7815 kern_type = KERN_TYPE_SHA256_SLTPWU;
7816 dgst_size = DGST_SIZE_4_8;
7817 parse_func = episerver4_parse_hash;
7818 sort_by_digest = sort_by_digest_4_8;
7819 opti_type = OPTI_TYPE_ZERO_BYTE
7820 | OPTI_TYPE_PRECOMPUTE_INIT
7821 | OPTI_TYPE_PRECOMPUTE_MERKLE
7822 | OPTI_TYPE_EARLY_SKIP
7823 | OPTI_TYPE_NOT_ITERATED
7824 | OPTI_TYPE_PREPENDED_SALT
7825 | OPTI_TYPE_RAW_HASH;
7826 dgst_pos0 = 3;
7827 dgst_pos1 = 7;
7828 dgst_pos2 = 2;
7829 dgst_pos3 = 6;
7830 break;
7831
7832 case 1450: hash_type = HASH_TYPE_SHA256;
7833 salt_type = SALT_TYPE_INTERN;
7834 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7835 opts_type = OPTS_TYPE_PT_GENERATE_BE
7836 | OPTS_TYPE_ST_ADD80;
7837 kern_type = KERN_TYPE_HMACSHA256_PW;
7838 dgst_size = DGST_SIZE_4_8;
7839 parse_func = hmacsha256_parse_hash;
7840 sort_by_digest = sort_by_digest_4_8;
7841 opti_type = OPTI_TYPE_ZERO_BYTE
7842 | OPTI_TYPE_NOT_ITERATED;
7843 dgst_pos0 = 3;
7844 dgst_pos1 = 7;
7845 dgst_pos2 = 2;
7846 dgst_pos3 = 6;
7847 break;
7848
7849 case 1460: hash_type = HASH_TYPE_SHA256;
7850 salt_type = SALT_TYPE_INTERN;
7851 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7852 opts_type = OPTS_TYPE_PT_GENERATE_BE
7853 | OPTS_TYPE_PT_ADD80
7854 | OPTS_TYPE_PT_ADDBITS15;
7855 kern_type = KERN_TYPE_HMACSHA256_SLT;
7856 dgst_size = DGST_SIZE_4_8;
7857 parse_func = hmacsha256_parse_hash;
7858 sort_by_digest = sort_by_digest_4_8;
7859 opti_type = OPTI_TYPE_ZERO_BYTE
7860 | OPTI_TYPE_NOT_ITERATED;
7861 dgst_pos0 = 3;
7862 dgst_pos1 = 7;
7863 dgst_pos2 = 2;
7864 dgst_pos3 = 6;
7865 break;
7866
7867 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7868 salt_type = SALT_TYPE_EMBEDDED;
7869 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7870 opts_type = OPTS_TYPE_PT_GENERATE_LE
7871 | OPTS_TYPE_PT_BITSLICE;
7872 kern_type = KERN_TYPE_DESCRYPT;
7873 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7874 parse_func = descrypt_parse_hash;
7875 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7876 opti_type = OPTI_TYPE_ZERO_BYTE
7877 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7878 dgst_pos0 = 0;
7879 dgst_pos1 = 1;
7880 dgst_pos2 = 2;
7881 dgst_pos3 = 3;
7882 break;
7883
7884 case 1600: hash_type = HASH_TYPE_MD5;
7885 salt_type = SALT_TYPE_EMBEDDED;
7886 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7887 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7888 kern_type = KERN_TYPE_APR1CRYPT;
7889 dgst_size = DGST_SIZE_4_4;
7890 parse_func = md5apr1_parse_hash;
7891 sort_by_digest = sort_by_digest_4_4;
7892 opti_type = OPTI_TYPE_ZERO_BYTE;
7893 dgst_pos0 = 0;
7894 dgst_pos1 = 1;
7895 dgst_pos2 = 2;
7896 dgst_pos3 = 3;
7897 break;
7898
7899 case 1700: hash_type = HASH_TYPE_SHA512;
7900 salt_type = SALT_TYPE_NONE;
7901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7902 opts_type = OPTS_TYPE_PT_GENERATE_BE
7903 | OPTS_TYPE_PT_ADD80
7904 | OPTS_TYPE_PT_ADDBITS15;
7905 kern_type = KERN_TYPE_SHA512;
7906 dgst_size = DGST_SIZE_8_8;
7907 parse_func = sha512_parse_hash;
7908 sort_by_digest = sort_by_digest_8_8;
7909 opti_type = OPTI_TYPE_ZERO_BYTE
7910 | OPTI_TYPE_PRECOMPUTE_INIT
7911 | OPTI_TYPE_PRECOMPUTE_MERKLE
7912 | OPTI_TYPE_EARLY_SKIP
7913 | OPTI_TYPE_NOT_ITERATED
7914 | OPTI_TYPE_NOT_SALTED
7915 | OPTI_TYPE_USES_BITS_64
7916 | OPTI_TYPE_RAW_HASH;
7917 dgst_pos0 = 14;
7918 dgst_pos1 = 15;
7919 dgst_pos2 = 6;
7920 dgst_pos3 = 7;
7921 break;
7922
7923 case 1710: hash_type = HASH_TYPE_SHA512;
7924 salt_type = SALT_TYPE_INTERN;
7925 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7926 opts_type = OPTS_TYPE_PT_GENERATE_BE
7927 | OPTS_TYPE_ST_ADD80
7928 | OPTS_TYPE_ST_ADDBITS15;
7929 kern_type = KERN_TYPE_SHA512_PWSLT;
7930 dgst_size = DGST_SIZE_8_8;
7931 parse_func = sha512s_parse_hash;
7932 sort_by_digest = sort_by_digest_8_8;
7933 opti_type = OPTI_TYPE_ZERO_BYTE
7934 | OPTI_TYPE_PRECOMPUTE_INIT
7935 | OPTI_TYPE_PRECOMPUTE_MERKLE
7936 | OPTI_TYPE_EARLY_SKIP
7937 | OPTI_TYPE_NOT_ITERATED
7938 | OPTI_TYPE_APPENDED_SALT
7939 | OPTI_TYPE_USES_BITS_64
7940 | OPTI_TYPE_RAW_HASH;
7941 dgst_pos0 = 14;
7942 dgst_pos1 = 15;
7943 dgst_pos2 = 6;
7944 dgst_pos3 = 7;
7945 break;
7946
7947 case 1711: hash_type = HASH_TYPE_SHA512;
7948 salt_type = SALT_TYPE_EMBEDDED;
7949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7950 opts_type = OPTS_TYPE_PT_GENERATE_BE
7951 | OPTS_TYPE_ST_ADD80
7952 | OPTS_TYPE_ST_ADDBITS15;
7953 kern_type = KERN_TYPE_SHA512_PWSLT;
7954 dgst_size = DGST_SIZE_8_8;
7955 parse_func = sha512b64s_parse_hash;
7956 sort_by_digest = sort_by_digest_8_8;
7957 opti_type = OPTI_TYPE_ZERO_BYTE
7958 | OPTI_TYPE_PRECOMPUTE_INIT
7959 | OPTI_TYPE_PRECOMPUTE_MERKLE
7960 | OPTI_TYPE_EARLY_SKIP
7961 | OPTI_TYPE_NOT_ITERATED
7962 | OPTI_TYPE_APPENDED_SALT
7963 | OPTI_TYPE_USES_BITS_64
7964 | OPTI_TYPE_RAW_HASH;
7965 dgst_pos0 = 14;
7966 dgst_pos1 = 15;
7967 dgst_pos2 = 6;
7968 dgst_pos3 = 7;
7969 break;
7970
7971 case 1720: hash_type = HASH_TYPE_SHA512;
7972 salt_type = SALT_TYPE_INTERN;
7973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7974 opts_type = OPTS_TYPE_PT_GENERATE_BE
7975 | OPTS_TYPE_PT_ADD80
7976 | OPTS_TYPE_PT_ADDBITS15;
7977 kern_type = KERN_TYPE_SHA512_SLTPW;
7978 dgst_size = DGST_SIZE_8_8;
7979 parse_func = sha512s_parse_hash;
7980 sort_by_digest = sort_by_digest_8_8;
7981 opti_type = OPTI_TYPE_ZERO_BYTE
7982 | OPTI_TYPE_PRECOMPUTE_INIT
7983 | OPTI_TYPE_PRECOMPUTE_MERKLE
7984 | OPTI_TYPE_EARLY_SKIP
7985 | OPTI_TYPE_NOT_ITERATED
7986 | OPTI_TYPE_PREPENDED_SALT
7987 | OPTI_TYPE_USES_BITS_64
7988 | OPTI_TYPE_RAW_HASH;
7989 dgst_pos0 = 14;
7990 dgst_pos1 = 15;
7991 dgst_pos2 = 6;
7992 dgst_pos3 = 7;
7993 break;
7994
7995 case 1722: hash_type = HASH_TYPE_SHA512;
7996 salt_type = SALT_TYPE_EMBEDDED;
7997 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7998 opts_type = OPTS_TYPE_PT_GENERATE_BE
7999 | OPTS_TYPE_PT_ADD80
8000 | OPTS_TYPE_PT_ADDBITS15
8001 | OPTS_TYPE_ST_HEX;
8002 kern_type = KERN_TYPE_SHA512_SLTPW;
8003 dgst_size = DGST_SIZE_8_8;
8004 parse_func = osx512_parse_hash;
8005 sort_by_digest = sort_by_digest_8_8;
8006 opti_type = OPTI_TYPE_ZERO_BYTE
8007 | OPTI_TYPE_PRECOMPUTE_INIT
8008 | OPTI_TYPE_PRECOMPUTE_MERKLE
8009 | OPTI_TYPE_EARLY_SKIP
8010 | OPTI_TYPE_NOT_ITERATED
8011 | OPTI_TYPE_PREPENDED_SALT
8012 | OPTI_TYPE_USES_BITS_64
8013 | OPTI_TYPE_RAW_HASH;
8014 dgst_pos0 = 14;
8015 dgst_pos1 = 15;
8016 dgst_pos2 = 6;
8017 dgst_pos3 = 7;
8018 break;
8019
8020 case 1730: hash_type = HASH_TYPE_SHA512;
8021 salt_type = SALT_TYPE_INTERN;
8022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8023 opts_type = OPTS_TYPE_PT_GENERATE_BE
8024 | OPTS_TYPE_PT_UNICODE
8025 | OPTS_TYPE_ST_ADD80
8026 | OPTS_TYPE_ST_ADDBITS15;
8027 kern_type = KERN_TYPE_SHA512_PWSLTU;
8028 dgst_size = DGST_SIZE_8_8;
8029 parse_func = sha512s_parse_hash;
8030 sort_by_digest = sort_by_digest_8_8;
8031 opti_type = OPTI_TYPE_ZERO_BYTE
8032 | OPTI_TYPE_PRECOMPUTE_INIT
8033 | OPTI_TYPE_PRECOMPUTE_MERKLE
8034 | OPTI_TYPE_EARLY_SKIP
8035 | OPTI_TYPE_NOT_ITERATED
8036 | OPTI_TYPE_APPENDED_SALT
8037 | OPTI_TYPE_USES_BITS_64
8038 | OPTI_TYPE_RAW_HASH;
8039 dgst_pos0 = 14;
8040 dgst_pos1 = 15;
8041 dgst_pos2 = 6;
8042 dgst_pos3 = 7;
8043 break;
8044
8045 case 1731: hash_type = HASH_TYPE_SHA512;
8046 salt_type = SALT_TYPE_EMBEDDED;
8047 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8048 opts_type = OPTS_TYPE_PT_GENERATE_BE
8049 | OPTS_TYPE_PT_UNICODE
8050 | OPTS_TYPE_ST_ADD80
8051 | OPTS_TYPE_ST_ADDBITS15
8052 | OPTS_TYPE_ST_HEX;
8053 kern_type = KERN_TYPE_SHA512_PWSLTU;
8054 dgst_size = DGST_SIZE_8_8;
8055 parse_func = mssql2012_parse_hash;
8056 sort_by_digest = sort_by_digest_8_8;
8057 opti_type = OPTI_TYPE_ZERO_BYTE
8058 | OPTI_TYPE_PRECOMPUTE_INIT
8059 | OPTI_TYPE_PRECOMPUTE_MERKLE
8060 | OPTI_TYPE_EARLY_SKIP
8061 | OPTI_TYPE_NOT_ITERATED
8062 | OPTI_TYPE_APPENDED_SALT
8063 | OPTI_TYPE_USES_BITS_64
8064 | OPTI_TYPE_RAW_HASH;
8065 dgst_pos0 = 14;
8066 dgst_pos1 = 15;
8067 dgst_pos2 = 6;
8068 dgst_pos3 = 7;
8069 break;
8070
8071 case 1740: hash_type = HASH_TYPE_SHA512;
8072 salt_type = SALT_TYPE_INTERN;
8073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8074 opts_type = OPTS_TYPE_PT_GENERATE_BE
8075 | OPTS_TYPE_PT_ADD80
8076 | OPTS_TYPE_PT_ADDBITS15
8077 | OPTS_TYPE_PT_UNICODE;
8078 kern_type = KERN_TYPE_SHA512_SLTPWU;
8079 dgst_size = DGST_SIZE_8_8;
8080 parse_func = sha512s_parse_hash;
8081 sort_by_digest = sort_by_digest_8_8;
8082 opti_type = OPTI_TYPE_ZERO_BYTE
8083 | OPTI_TYPE_PRECOMPUTE_INIT
8084 | OPTI_TYPE_PRECOMPUTE_MERKLE
8085 | OPTI_TYPE_EARLY_SKIP
8086 | OPTI_TYPE_NOT_ITERATED
8087 | OPTI_TYPE_PREPENDED_SALT
8088 | OPTI_TYPE_USES_BITS_64
8089 | OPTI_TYPE_RAW_HASH;
8090 dgst_pos0 = 14;
8091 dgst_pos1 = 15;
8092 dgst_pos2 = 6;
8093 dgst_pos3 = 7;
8094 break;
8095
8096 case 1750: hash_type = HASH_TYPE_SHA512;
8097 salt_type = SALT_TYPE_INTERN;
8098 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8099 opts_type = OPTS_TYPE_PT_GENERATE_BE
8100 | OPTS_TYPE_ST_ADD80;
8101 kern_type = KERN_TYPE_HMACSHA512_PW;
8102 dgst_size = DGST_SIZE_8_8;
8103 parse_func = hmacsha512_parse_hash;
8104 sort_by_digest = sort_by_digest_8_8;
8105 opti_type = OPTI_TYPE_ZERO_BYTE
8106 | OPTI_TYPE_USES_BITS_64
8107 | OPTI_TYPE_NOT_ITERATED;
8108 dgst_pos0 = 14;
8109 dgst_pos1 = 15;
8110 dgst_pos2 = 6;
8111 dgst_pos3 = 7;
8112 break;
8113
8114 case 1760: hash_type = HASH_TYPE_SHA512;
8115 salt_type = SALT_TYPE_INTERN;
8116 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8117 opts_type = OPTS_TYPE_PT_GENERATE_BE
8118 | OPTS_TYPE_PT_ADD80
8119 | OPTS_TYPE_PT_ADDBITS15;
8120 kern_type = KERN_TYPE_HMACSHA512_SLT;
8121 dgst_size = DGST_SIZE_8_8;
8122 parse_func = hmacsha512_parse_hash;
8123 sort_by_digest = sort_by_digest_8_8;
8124 opti_type = OPTI_TYPE_ZERO_BYTE
8125 | OPTI_TYPE_USES_BITS_64
8126 | OPTI_TYPE_NOT_ITERATED;
8127 dgst_pos0 = 14;
8128 dgst_pos1 = 15;
8129 dgst_pos2 = 6;
8130 dgst_pos3 = 7;
8131 break;
8132
8133 case 1800: hash_type = HASH_TYPE_SHA512;
8134 salt_type = SALT_TYPE_EMBEDDED;
8135 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8136 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8137 kern_type = KERN_TYPE_SHA512CRYPT;
8138 dgst_size = DGST_SIZE_8_8;
8139 parse_func = sha512crypt_parse_hash;
8140 sort_by_digest = sort_by_digest_8_8;
8141 opti_type = OPTI_TYPE_ZERO_BYTE
8142 | OPTI_TYPE_USES_BITS_64;
8143 dgst_pos0 = 0;
8144 dgst_pos1 = 1;
8145 dgst_pos2 = 2;
8146 dgst_pos3 = 3;
8147 break;
8148
8149 case 2100: hash_type = HASH_TYPE_DCC2;
8150 salt_type = SALT_TYPE_EMBEDDED;
8151 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8152 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8153 | OPTS_TYPE_ST_LOWER
8154 | OPTS_TYPE_ST_UNICODE;
8155 kern_type = KERN_TYPE_DCC2;
8156 dgst_size = DGST_SIZE_4_4;
8157 parse_func = dcc2_parse_hash;
8158 sort_by_digest = sort_by_digest_4_4;
8159 opti_type = OPTI_TYPE_ZERO_BYTE;
8160 dgst_pos0 = 0;
8161 dgst_pos1 = 1;
8162 dgst_pos2 = 2;
8163 dgst_pos3 = 3;
8164 break;
8165
8166 case 2400: hash_type = HASH_TYPE_MD5;
8167 salt_type = SALT_TYPE_NONE;
8168 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8169 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8170 kern_type = KERN_TYPE_MD5PIX;
8171 dgst_size = DGST_SIZE_4_4;
8172 parse_func = md5pix_parse_hash;
8173 sort_by_digest = sort_by_digest_4_4;
8174 opti_type = OPTI_TYPE_ZERO_BYTE
8175 | OPTI_TYPE_PRECOMPUTE_INIT
8176 | OPTI_TYPE_PRECOMPUTE_MERKLE
8177 | OPTI_TYPE_EARLY_SKIP
8178 | OPTI_TYPE_NOT_ITERATED
8179 | OPTI_TYPE_NOT_SALTED;
8180 dgst_pos0 = 0;
8181 dgst_pos1 = 3;
8182 dgst_pos2 = 2;
8183 dgst_pos3 = 1;
8184 break;
8185
8186 case 2410: hash_type = HASH_TYPE_MD5;
8187 salt_type = SALT_TYPE_INTERN;
8188 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8189 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8190 kern_type = KERN_TYPE_MD5ASA;
8191 dgst_size = DGST_SIZE_4_4;
8192 parse_func = md5asa_parse_hash;
8193 sort_by_digest = sort_by_digest_4_4;
8194 opti_type = OPTI_TYPE_ZERO_BYTE
8195 | OPTI_TYPE_PRECOMPUTE_INIT
8196 | OPTI_TYPE_PRECOMPUTE_MERKLE
8197 | OPTI_TYPE_EARLY_SKIP
8198 | OPTI_TYPE_NOT_ITERATED;
8199 dgst_pos0 = 0;
8200 dgst_pos1 = 3;
8201 dgst_pos2 = 2;
8202 dgst_pos3 = 1;
8203 break;
8204
8205 case 2500: hash_type = HASH_TYPE_WPA;
8206 salt_type = SALT_TYPE_EMBEDDED;
8207 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8208 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8209 kern_type = KERN_TYPE_WPA;
8210 dgst_size = DGST_SIZE_4_4;
8211 parse_func = wpa_parse_hash;
8212 sort_by_digest = sort_by_digest_4_4;
8213 opti_type = OPTI_TYPE_ZERO_BYTE;
8214 dgst_pos0 = 0;
8215 dgst_pos1 = 1;
8216 dgst_pos2 = 2;
8217 dgst_pos3 = 3;
8218 break;
8219
8220 case 2600: hash_type = HASH_TYPE_MD5;
8221 salt_type = SALT_TYPE_VIRTUAL;
8222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8223 opts_type = OPTS_TYPE_PT_GENERATE_LE
8224 | OPTS_TYPE_PT_ADD80
8225 | OPTS_TYPE_PT_ADDBITS14
8226 | OPTS_TYPE_ST_ADD80;
8227 kern_type = KERN_TYPE_MD55_PWSLT1;
8228 dgst_size = DGST_SIZE_4_4;
8229 parse_func = md5md5_parse_hash;
8230 sort_by_digest = sort_by_digest_4_4;
8231 opti_type = OPTI_TYPE_ZERO_BYTE
8232 | OPTI_TYPE_PRECOMPUTE_INIT
8233 | OPTI_TYPE_PRECOMPUTE_MERKLE
8234 | OPTI_TYPE_EARLY_SKIP;
8235 dgst_pos0 = 0;
8236 dgst_pos1 = 3;
8237 dgst_pos2 = 2;
8238 dgst_pos3 = 1;
8239 break;
8240
8241 case 2611: hash_type = HASH_TYPE_MD5;
8242 salt_type = SALT_TYPE_INTERN;
8243 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8244 opts_type = OPTS_TYPE_PT_GENERATE_LE
8245 | OPTS_TYPE_PT_ADD80
8246 | OPTS_TYPE_PT_ADDBITS14
8247 | OPTS_TYPE_ST_ADD80;
8248 kern_type = KERN_TYPE_MD55_PWSLT1;
8249 dgst_size = DGST_SIZE_4_4;
8250 parse_func = vb3_parse_hash;
8251 sort_by_digest = sort_by_digest_4_4;
8252 opti_type = OPTI_TYPE_ZERO_BYTE
8253 | OPTI_TYPE_PRECOMPUTE_INIT
8254 | OPTI_TYPE_PRECOMPUTE_MERKLE
8255 | OPTI_TYPE_EARLY_SKIP;
8256 dgst_pos0 = 0;
8257 dgst_pos1 = 3;
8258 dgst_pos2 = 2;
8259 dgst_pos3 = 1;
8260 break;
8261
8262 case 2612: hash_type = HASH_TYPE_MD5;
8263 salt_type = SALT_TYPE_EMBEDDED;
8264 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8265 opts_type = OPTS_TYPE_PT_GENERATE_LE
8266 | OPTS_TYPE_PT_ADD80
8267 | OPTS_TYPE_PT_ADDBITS14
8268 | OPTS_TYPE_ST_ADD80
8269 | OPTS_TYPE_ST_HEX;
8270 kern_type = KERN_TYPE_MD55_PWSLT1;
8271 dgst_size = DGST_SIZE_4_4;
8272 parse_func = phps_parse_hash;
8273 sort_by_digest = sort_by_digest_4_4;
8274 opti_type = OPTI_TYPE_ZERO_BYTE
8275 | OPTI_TYPE_PRECOMPUTE_INIT
8276 | OPTI_TYPE_PRECOMPUTE_MERKLE
8277 | OPTI_TYPE_EARLY_SKIP;
8278 dgst_pos0 = 0;
8279 dgst_pos1 = 3;
8280 dgst_pos2 = 2;
8281 dgst_pos3 = 1;
8282 break;
8283
8284 case 2711: hash_type = HASH_TYPE_MD5;
8285 salt_type = SALT_TYPE_INTERN;
8286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8287 opts_type = OPTS_TYPE_PT_GENERATE_LE
8288 | OPTS_TYPE_PT_ADD80
8289 | OPTS_TYPE_PT_ADDBITS14
8290 | OPTS_TYPE_ST_ADD80;
8291 kern_type = KERN_TYPE_MD55_PWSLT2;
8292 dgst_size = DGST_SIZE_4_4;
8293 parse_func = vb30_parse_hash;
8294 sort_by_digest = sort_by_digest_4_4;
8295 opti_type = OPTI_TYPE_ZERO_BYTE
8296 | OPTI_TYPE_PRECOMPUTE_INIT
8297 | OPTI_TYPE_EARLY_SKIP;
8298 dgst_pos0 = 0;
8299 dgst_pos1 = 3;
8300 dgst_pos2 = 2;
8301 dgst_pos3 = 1;
8302 break;
8303
8304 case 2811: hash_type = HASH_TYPE_MD5;
8305 salt_type = SALT_TYPE_INTERN;
8306 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8307 opts_type = OPTS_TYPE_PT_GENERATE_LE
8308 | OPTS_TYPE_PT_ADD80
8309 | OPTS_TYPE_PT_ADDBITS14;
8310 kern_type = KERN_TYPE_MD55_SLTPW;
8311 dgst_size = DGST_SIZE_4_4;
8312 parse_func = ipb2_parse_hash;
8313 sort_by_digest = sort_by_digest_4_4;
8314 opti_type = OPTI_TYPE_ZERO_BYTE
8315 | OPTI_TYPE_PRECOMPUTE_INIT
8316 | OPTI_TYPE_EARLY_SKIP;
8317 dgst_pos0 = 0;
8318 dgst_pos1 = 3;
8319 dgst_pos2 = 2;
8320 dgst_pos3 = 1;
8321 break;
8322
8323 case 3000: hash_type = HASH_TYPE_LM;
8324 salt_type = SALT_TYPE_NONE;
8325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8326 opts_type = OPTS_TYPE_PT_GENERATE_LE
8327 | OPTS_TYPE_PT_UPPER
8328 | OPTS_TYPE_PT_BITSLICE;
8329 kern_type = KERN_TYPE_LM;
8330 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8331 parse_func = lm_parse_hash;
8332 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8333 opti_type = OPTI_TYPE_ZERO_BYTE
8334 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8335 dgst_pos0 = 0;
8336 dgst_pos1 = 1;
8337 dgst_pos2 = 2;
8338 dgst_pos3 = 3;
8339 break;
8340
8341 case 3100: hash_type = HASH_TYPE_ORACLEH;
8342 salt_type = SALT_TYPE_INTERN;
8343 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8344 opts_type = OPTS_TYPE_PT_GENERATE_LE
8345 | OPTS_TYPE_PT_UPPER
8346 | OPTS_TYPE_ST_UPPER;
8347 kern_type = KERN_TYPE_ORACLEH;
8348 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8349 parse_func = oracleh_parse_hash;
8350 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8351 opti_type = OPTI_TYPE_ZERO_BYTE;
8352 dgst_pos0 = 0;
8353 dgst_pos1 = 1;
8354 dgst_pos2 = 2;
8355 dgst_pos3 = 3;
8356 break;
8357
8358 case 3200: hash_type = HASH_TYPE_BCRYPT;
8359 salt_type = SALT_TYPE_EMBEDDED;
8360 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8361 opts_type = OPTS_TYPE_PT_GENERATE_LE
8362 | OPTS_TYPE_ST_GENERATE_LE;
8363 kern_type = KERN_TYPE_BCRYPT;
8364 dgst_size = DGST_SIZE_4_6;
8365 parse_func = bcrypt_parse_hash;
8366 sort_by_digest = sort_by_digest_4_6;
8367 opti_type = OPTI_TYPE_ZERO_BYTE;
8368 dgst_pos0 = 0;
8369 dgst_pos1 = 1;
8370 dgst_pos2 = 2;
8371 dgst_pos3 = 3;
8372 break;
8373
8374 case 3710: hash_type = HASH_TYPE_MD5;
8375 salt_type = SALT_TYPE_INTERN;
8376 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8377 opts_type = OPTS_TYPE_PT_GENERATE_LE
8378 | OPTS_TYPE_PT_ADD80
8379 | OPTS_TYPE_PT_ADDBITS14;
8380 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8381 dgst_size = DGST_SIZE_4_4;
8382 parse_func = md5s_parse_hash;
8383 sort_by_digest = sort_by_digest_4_4;
8384 opti_type = OPTI_TYPE_ZERO_BYTE
8385 | OPTI_TYPE_PRECOMPUTE_INIT
8386 | OPTI_TYPE_PRECOMPUTE_MERKLE
8387 | OPTI_TYPE_EARLY_SKIP;
8388 dgst_pos0 = 0;
8389 dgst_pos1 = 3;
8390 dgst_pos2 = 2;
8391 dgst_pos3 = 1;
8392 break;
8393
8394 case 3711: hash_type = HASH_TYPE_MD5;
8395 salt_type = SALT_TYPE_EMBEDDED;
8396 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8397 opts_type = OPTS_TYPE_PT_GENERATE_LE
8398 | OPTS_TYPE_PT_ADD80
8399 | OPTS_TYPE_PT_ADDBITS14;
8400 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8401 dgst_size = DGST_SIZE_4_4;
8402 parse_func = mediawiki_b_parse_hash;
8403 sort_by_digest = sort_by_digest_4_4;
8404 opti_type = OPTI_TYPE_ZERO_BYTE
8405 | OPTI_TYPE_PRECOMPUTE_INIT
8406 | OPTI_TYPE_PRECOMPUTE_MERKLE
8407 | OPTI_TYPE_EARLY_SKIP;
8408 dgst_pos0 = 0;
8409 dgst_pos1 = 3;
8410 dgst_pos2 = 2;
8411 dgst_pos3 = 1;
8412 break;
8413
8414 case 3800: hash_type = HASH_TYPE_MD5;
8415 salt_type = SALT_TYPE_INTERN;
8416 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8417 opts_type = OPTS_TYPE_PT_GENERATE_LE
8418 | OPTS_TYPE_ST_ADDBITS14;
8419 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8420 dgst_size = DGST_SIZE_4_4;
8421 parse_func = md5s_parse_hash;
8422 sort_by_digest = sort_by_digest_4_4;
8423 opti_type = OPTI_TYPE_ZERO_BYTE
8424 | OPTI_TYPE_PRECOMPUTE_INIT
8425 | OPTI_TYPE_PRECOMPUTE_MERKLE
8426 | OPTI_TYPE_EARLY_SKIP
8427 | OPTI_TYPE_NOT_ITERATED
8428 | OPTI_TYPE_RAW_HASH;
8429 dgst_pos0 = 0;
8430 dgst_pos1 = 3;
8431 dgst_pos2 = 2;
8432 dgst_pos3 = 1;
8433 break;
8434
8435 case 4300: hash_type = HASH_TYPE_MD5;
8436 salt_type = SALT_TYPE_VIRTUAL;
8437 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8438 opts_type = OPTS_TYPE_PT_GENERATE_LE
8439 | OPTS_TYPE_PT_ADD80
8440 | OPTS_TYPE_PT_ADDBITS14
8441 | OPTS_TYPE_ST_ADD80;
8442 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8443 dgst_size = DGST_SIZE_4_4;
8444 parse_func = md5md5_parse_hash;
8445 sort_by_digest = sort_by_digest_4_4;
8446 opti_type = OPTI_TYPE_ZERO_BYTE
8447 | OPTI_TYPE_PRECOMPUTE_INIT
8448 | OPTI_TYPE_PRECOMPUTE_MERKLE
8449 | OPTI_TYPE_EARLY_SKIP;
8450 dgst_pos0 = 0;
8451 dgst_pos1 = 3;
8452 dgst_pos2 = 2;
8453 dgst_pos3 = 1;
8454 break;
8455
8456
8457 case 4400: hash_type = HASH_TYPE_MD5;
8458 salt_type = SALT_TYPE_NONE;
8459 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8460 opts_type = OPTS_TYPE_PT_GENERATE_BE
8461 | OPTS_TYPE_PT_ADD80
8462 | OPTS_TYPE_PT_ADDBITS15;
8463 kern_type = KERN_TYPE_MD5_SHA1;
8464 dgst_size = DGST_SIZE_4_4;
8465 parse_func = md5_parse_hash;
8466 sort_by_digest = sort_by_digest_4_4;
8467 opti_type = OPTI_TYPE_ZERO_BYTE
8468 | OPTI_TYPE_PRECOMPUTE_INIT
8469 | OPTI_TYPE_PRECOMPUTE_MERKLE
8470 | OPTI_TYPE_EARLY_SKIP
8471 | OPTI_TYPE_NOT_ITERATED
8472 | OPTI_TYPE_NOT_SALTED
8473 | OPTI_TYPE_RAW_HASH;
8474 dgst_pos0 = 0;
8475 dgst_pos1 = 3;
8476 dgst_pos2 = 2;
8477 dgst_pos3 = 1;
8478 break;
8479
8480 case 4500: hash_type = HASH_TYPE_SHA1;
8481 salt_type = SALT_TYPE_NONE;
8482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8483 opts_type = OPTS_TYPE_PT_GENERATE_BE
8484 | OPTS_TYPE_PT_ADD80
8485 | OPTS_TYPE_PT_ADDBITS15;
8486 kern_type = KERN_TYPE_SHA11;
8487 dgst_size = DGST_SIZE_4_5;
8488 parse_func = sha1_parse_hash;
8489 sort_by_digest = sort_by_digest_4_5;
8490 opti_type = OPTI_TYPE_ZERO_BYTE
8491 | OPTI_TYPE_PRECOMPUTE_INIT
8492 | OPTI_TYPE_PRECOMPUTE_MERKLE
8493 | OPTI_TYPE_EARLY_SKIP
8494 | OPTI_TYPE_NOT_SALTED;
8495 dgst_pos0 = 3;
8496 dgst_pos1 = 4;
8497 dgst_pos2 = 2;
8498 dgst_pos3 = 1;
8499 break;
8500
8501 case 4700: hash_type = HASH_TYPE_SHA1;
8502 salt_type = SALT_TYPE_NONE;
8503 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8504 opts_type = OPTS_TYPE_PT_GENERATE_LE
8505 | OPTS_TYPE_PT_ADD80
8506 | OPTS_TYPE_PT_ADDBITS14;
8507 kern_type = KERN_TYPE_SHA1_MD5;
8508 dgst_size = DGST_SIZE_4_5;
8509 parse_func = sha1_parse_hash;
8510 sort_by_digest = sort_by_digest_4_5;
8511 opti_type = OPTI_TYPE_ZERO_BYTE
8512 | OPTI_TYPE_PRECOMPUTE_INIT
8513 | OPTI_TYPE_PRECOMPUTE_MERKLE
8514 | OPTI_TYPE_EARLY_SKIP
8515 | OPTI_TYPE_NOT_ITERATED
8516 | OPTI_TYPE_NOT_SALTED
8517 | OPTI_TYPE_RAW_HASH;
8518 dgst_pos0 = 3;
8519 dgst_pos1 = 4;
8520 dgst_pos2 = 2;
8521 dgst_pos3 = 1;
8522 break;
8523
8524 case 4800: hash_type = HASH_TYPE_MD5;
8525 salt_type = SALT_TYPE_EMBEDDED;
8526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8527 opts_type = OPTS_TYPE_PT_GENERATE_LE
8528 | OPTS_TYPE_PT_ADDBITS14;
8529 kern_type = KERN_TYPE_MD5_CHAP;
8530 dgst_size = DGST_SIZE_4_4;
8531 parse_func = chap_parse_hash;
8532 sort_by_digest = sort_by_digest_4_4;
8533 opti_type = OPTI_TYPE_ZERO_BYTE
8534 | OPTI_TYPE_PRECOMPUTE_INIT
8535 | OPTI_TYPE_PRECOMPUTE_MERKLE
8536 | OPTI_TYPE_MEET_IN_MIDDLE
8537 | OPTI_TYPE_EARLY_SKIP
8538 | OPTI_TYPE_NOT_ITERATED
8539 | OPTI_TYPE_RAW_HASH;
8540 dgst_pos0 = 0;
8541 dgst_pos1 = 3;
8542 dgst_pos2 = 2;
8543 dgst_pos3 = 1;
8544 break;
8545
8546 case 4900: hash_type = HASH_TYPE_SHA1;
8547 salt_type = SALT_TYPE_INTERN;
8548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8549 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8550 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8551 dgst_size = DGST_SIZE_4_5;
8552 parse_func = sha1s_parse_hash;
8553 sort_by_digest = sort_by_digest_4_5;
8554 opti_type = OPTI_TYPE_ZERO_BYTE
8555 | OPTI_TYPE_PRECOMPUTE_INIT
8556 | OPTI_TYPE_PRECOMPUTE_MERKLE
8557 | OPTI_TYPE_EARLY_SKIP;
8558 dgst_pos0 = 3;
8559 dgst_pos1 = 4;
8560 dgst_pos2 = 2;
8561 dgst_pos3 = 1;
8562 break;
8563
8564 case 5000: hash_type = HASH_TYPE_KECCAK;
8565 salt_type = SALT_TYPE_EMBEDDED;
8566 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8567 opts_type = OPTS_TYPE_PT_GENERATE_LE
8568 | OPTS_TYPE_PT_ADD01;
8569 kern_type = KERN_TYPE_KECCAK;
8570 dgst_size = DGST_SIZE_8_25;
8571 parse_func = keccak_parse_hash;
8572 sort_by_digest = sort_by_digest_8_25;
8573 opti_type = OPTI_TYPE_ZERO_BYTE
8574 | OPTI_TYPE_USES_BITS_64
8575 | OPTI_TYPE_RAW_HASH;
8576 dgst_pos0 = 2;
8577 dgst_pos1 = 3;
8578 dgst_pos2 = 4;
8579 dgst_pos3 = 5;
8580 break;
8581
8582 case 5100: hash_type = HASH_TYPE_MD5H;
8583 salt_type = SALT_TYPE_NONE;
8584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8585 opts_type = OPTS_TYPE_PT_GENERATE_LE
8586 | OPTS_TYPE_PT_ADD80
8587 | OPTS_TYPE_PT_ADDBITS14;
8588 kern_type = KERN_TYPE_MD5H;
8589 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8590 parse_func = md5half_parse_hash;
8591 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8592 opti_type = OPTI_TYPE_ZERO_BYTE
8593 | OPTI_TYPE_RAW_HASH;
8594 dgst_pos0 = 0;
8595 dgst_pos1 = 1;
8596 dgst_pos2 = 2;
8597 dgst_pos3 = 3;
8598 break;
8599
8600 case 5200: hash_type = HASH_TYPE_SHA256;
8601 salt_type = SALT_TYPE_EMBEDDED;
8602 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8603 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8604 kern_type = KERN_TYPE_PSAFE3;
8605 dgst_size = DGST_SIZE_4_8;
8606 parse_func = psafe3_parse_hash;
8607 sort_by_digest = sort_by_digest_4_8;
8608 opti_type = OPTI_TYPE_ZERO_BYTE;
8609 dgst_pos0 = 0;
8610 dgst_pos1 = 1;
8611 dgst_pos2 = 2;
8612 dgst_pos3 = 3;
8613 break;
8614
8615 case 5300: hash_type = HASH_TYPE_MD5;
8616 salt_type = SALT_TYPE_EMBEDDED;
8617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8618 opts_type = OPTS_TYPE_PT_GENERATE_LE
8619 | OPTS_TYPE_ST_ADD80;
8620 kern_type = KERN_TYPE_IKEPSK_MD5;
8621 dgst_size = DGST_SIZE_4_4;
8622 parse_func = ikepsk_md5_parse_hash;
8623 sort_by_digest = sort_by_digest_4_4;
8624 opti_type = OPTI_TYPE_ZERO_BYTE;
8625 dgst_pos0 = 0;
8626 dgst_pos1 = 3;
8627 dgst_pos2 = 2;
8628 dgst_pos3 = 1;
8629 break;
8630
8631 case 5400: hash_type = HASH_TYPE_SHA1;
8632 salt_type = SALT_TYPE_EMBEDDED;
8633 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8634 opts_type = OPTS_TYPE_PT_GENERATE_BE
8635 | OPTS_TYPE_ST_ADD80;
8636 kern_type = KERN_TYPE_IKEPSK_SHA1;
8637 dgst_size = DGST_SIZE_4_5;
8638 parse_func = ikepsk_sha1_parse_hash;
8639 sort_by_digest = sort_by_digest_4_5;
8640 opti_type = OPTI_TYPE_ZERO_BYTE;
8641 dgst_pos0 = 3;
8642 dgst_pos1 = 4;
8643 dgst_pos2 = 2;
8644 dgst_pos3 = 1;
8645 break;
8646
8647 case 5500: hash_type = HASH_TYPE_NETNTLM;
8648 salt_type = SALT_TYPE_EMBEDDED;
8649 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8650 opts_type = OPTS_TYPE_PT_GENERATE_LE
8651 | OPTS_TYPE_PT_ADD80
8652 | OPTS_TYPE_PT_ADDBITS14
8653 | OPTS_TYPE_PT_UNICODE
8654 | OPTS_TYPE_ST_HEX;
8655 kern_type = KERN_TYPE_NETNTLMv1;
8656 dgst_size = DGST_SIZE_4_4;
8657 parse_func = netntlmv1_parse_hash;
8658 sort_by_digest = sort_by_digest_4_4;
8659 opti_type = OPTI_TYPE_ZERO_BYTE
8660 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8661 dgst_pos0 = 0;
8662 dgst_pos1 = 1;
8663 dgst_pos2 = 2;
8664 dgst_pos3 = 3;
8665 break;
8666
8667 case 5600: hash_type = HASH_TYPE_MD5;
8668 salt_type = SALT_TYPE_EMBEDDED;
8669 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8670 opts_type = OPTS_TYPE_PT_GENERATE_LE
8671 | OPTS_TYPE_PT_ADD80
8672 | OPTS_TYPE_PT_ADDBITS14
8673 | OPTS_TYPE_PT_UNICODE;
8674 kern_type = KERN_TYPE_NETNTLMv2;
8675 dgst_size = DGST_SIZE_4_4;
8676 parse_func = netntlmv2_parse_hash;
8677 sort_by_digest = sort_by_digest_4_4;
8678 opti_type = OPTI_TYPE_ZERO_BYTE;
8679 dgst_pos0 = 0;
8680 dgst_pos1 = 3;
8681 dgst_pos2 = 2;
8682 dgst_pos3 = 1;
8683 break;
8684
8685 case 5700: hash_type = HASH_TYPE_SHA256;
8686 salt_type = SALT_TYPE_NONE;
8687 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8688 opts_type = OPTS_TYPE_PT_GENERATE_BE
8689 | OPTS_TYPE_PT_ADD80
8690 | OPTS_TYPE_PT_ADDBITS15;
8691 kern_type = KERN_TYPE_SHA256;
8692 dgst_size = DGST_SIZE_4_8;
8693 parse_func = cisco4_parse_hash;
8694 sort_by_digest = sort_by_digest_4_8;
8695 opti_type = OPTI_TYPE_ZERO_BYTE
8696 | OPTI_TYPE_PRECOMPUTE_INIT
8697 | OPTI_TYPE_PRECOMPUTE_MERKLE
8698 | OPTI_TYPE_EARLY_SKIP
8699 | OPTI_TYPE_NOT_ITERATED
8700 | OPTI_TYPE_NOT_SALTED
8701 | OPTI_TYPE_RAW_HASH;
8702 dgst_pos0 = 3;
8703 dgst_pos1 = 7;
8704 dgst_pos2 = 2;
8705 dgst_pos3 = 6;
8706 break;
8707
8708 case 5800: hash_type = HASH_TYPE_SHA1;
8709 salt_type = SALT_TYPE_INTERN;
8710 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8711 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8712 | OPTS_TYPE_ST_ADD80;
8713 kern_type = KERN_TYPE_ANDROIDPIN;
8714 dgst_size = DGST_SIZE_4_5;
8715 parse_func = androidpin_parse_hash;
8716 sort_by_digest = sort_by_digest_4_5;
8717 opti_type = OPTI_TYPE_ZERO_BYTE;
8718 dgst_pos0 = 0;
8719 dgst_pos1 = 1;
8720 dgst_pos2 = 2;
8721 dgst_pos3 = 3;
8722 break;
8723
8724 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8725 salt_type = SALT_TYPE_NONE;
8726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8727 opts_type = OPTS_TYPE_PT_GENERATE_LE
8728 | OPTS_TYPE_PT_ADD80;
8729 kern_type = KERN_TYPE_RIPEMD160;
8730 dgst_size = DGST_SIZE_4_5;
8731 parse_func = ripemd160_parse_hash;
8732 sort_by_digest = sort_by_digest_4_5;
8733 opti_type = OPTI_TYPE_ZERO_BYTE;
8734 dgst_pos0 = 0;
8735 dgst_pos1 = 1;
8736 dgst_pos2 = 2;
8737 dgst_pos3 = 3;
8738 break;
8739
8740 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8741 salt_type = SALT_TYPE_NONE;
8742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8743 opts_type = OPTS_TYPE_PT_GENERATE_BE
8744 | OPTS_TYPE_PT_ADD80;
8745 kern_type = KERN_TYPE_WHIRLPOOL;
8746 dgst_size = DGST_SIZE_4_16;
8747 parse_func = whirlpool_parse_hash;
8748 sort_by_digest = sort_by_digest_4_16;
8749 opti_type = OPTI_TYPE_ZERO_BYTE;
8750 dgst_pos0 = 0;
8751 dgst_pos1 = 1;
8752 dgst_pos2 = 2;
8753 dgst_pos3 = 3;
8754 break;
8755
8756 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8757 salt_type = SALT_TYPE_EMBEDDED;
8758 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8759 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8760 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8761 dgst_size = DGST_SIZE_4_5;
8762 parse_func = truecrypt_parse_hash_2k;
8763 sort_by_digest = sort_by_digest_4_5;
8764 opti_type = OPTI_TYPE_ZERO_BYTE;
8765 dgst_pos0 = 0;
8766 dgst_pos1 = 1;
8767 dgst_pos2 = 2;
8768 dgst_pos3 = 3;
8769 break;
8770
8771 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8772 salt_type = SALT_TYPE_EMBEDDED;
8773 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8774 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8775 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8776 dgst_size = DGST_SIZE_4_5;
8777 parse_func = truecrypt_parse_hash_2k;
8778 sort_by_digest = sort_by_digest_4_5;
8779 opti_type = OPTI_TYPE_ZERO_BYTE;
8780 dgst_pos0 = 0;
8781 dgst_pos1 = 1;
8782 dgst_pos2 = 2;
8783 dgst_pos3 = 3;
8784 break;
8785
8786 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8787 salt_type = SALT_TYPE_EMBEDDED;
8788 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8789 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8790 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8791 dgst_size = DGST_SIZE_4_5;
8792 parse_func = truecrypt_parse_hash_2k;
8793 sort_by_digest = sort_by_digest_4_5;
8794 opti_type = OPTI_TYPE_ZERO_BYTE;
8795 dgst_pos0 = 0;
8796 dgst_pos1 = 1;
8797 dgst_pos2 = 2;
8798 dgst_pos3 = 3;
8799 break;
8800
8801 case 6221: hash_type = HASH_TYPE_SHA512;
8802 salt_type = SALT_TYPE_EMBEDDED;
8803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8804 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8805 kern_type = KERN_TYPE_TCSHA512_XTS512;
8806 dgst_size = DGST_SIZE_8_8;
8807 parse_func = truecrypt_parse_hash_1k;
8808 sort_by_digest = sort_by_digest_8_8;
8809 opti_type = OPTI_TYPE_ZERO_BYTE
8810 | OPTI_TYPE_USES_BITS_64;
8811 dgst_pos0 = 0;
8812 dgst_pos1 = 1;
8813 dgst_pos2 = 2;
8814 dgst_pos3 = 3;
8815 break;
8816
8817 case 6222: hash_type = HASH_TYPE_SHA512;
8818 salt_type = SALT_TYPE_EMBEDDED;
8819 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8820 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8821 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8822 dgst_size = DGST_SIZE_8_8;
8823 parse_func = truecrypt_parse_hash_1k;
8824 sort_by_digest = sort_by_digest_8_8;
8825 opti_type = OPTI_TYPE_ZERO_BYTE
8826 | OPTI_TYPE_USES_BITS_64;
8827 dgst_pos0 = 0;
8828 dgst_pos1 = 1;
8829 dgst_pos2 = 2;
8830 dgst_pos3 = 3;
8831 break;
8832
8833 case 6223: hash_type = HASH_TYPE_SHA512;
8834 salt_type = SALT_TYPE_EMBEDDED;
8835 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8836 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8837 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8838 dgst_size = DGST_SIZE_8_8;
8839 parse_func = truecrypt_parse_hash_1k;
8840 sort_by_digest = sort_by_digest_8_8;
8841 opti_type = OPTI_TYPE_ZERO_BYTE
8842 | OPTI_TYPE_USES_BITS_64;
8843 dgst_pos0 = 0;
8844 dgst_pos1 = 1;
8845 dgst_pos2 = 2;
8846 dgst_pos3 = 3;
8847 break;
8848
8849 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8850 salt_type = SALT_TYPE_EMBEDDED;
8851 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8852 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8853 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8854 dgst_size = DGST_SIZE_4_8;
8855 parse_func = truecrypt_parse_hash_1k;
8856 sort_by_digest = sort_by_digest_4_8;
8857 opti_type = OPTI_TYPE_ZERO_BYTE;
8858 dgst_pos0 = 0;
8859 dgst_pos1 = 1;
8860 dgst_pos2 = 2;
8861 dgst_pos3 = 3;
8862 break;
8863
8864 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8865 salt_type = SALT_TYPE_EMBEDDED;
8866 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8867 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8868 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8869 dgst_size = DGST_SIZE_4_8;
8870 parse_func = truecrypt_parse_hash_1k;
8871 sort_by_digest = sort_by_digest_4_8;
8872 opti_type = OPTI_TYPE_ZERO_BYTE;
8873 dgst_pos0 = 0;
8874 dgst_pos1 = 1;
8875 dgst_pos2 = 2;
8876 dgst_pos3 = 3;
8877 break;
8878
8879 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8880 salt_type = SALT_TYPE_EMBEDDED;
8881 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8882 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8883 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8884 dgst_size = DGST_SIZE_4_8;
8885 parse_func = truecrypt_parse_hash_1k;
8886 sort_by_digest = sort_by_digest_4_8;
8887 opti_type = OPTI_TYPE_ZERO_BYTE;
8888 dgst_pos0 = 0;
8889 dgst_pos1 = 1;
8890 dgst_pos2 = 2;
8891 dgst_pos3 = 3;
8892 break;
8893
8894 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8895 salt_type = SALT_TYPE_EMBEDDED;
8896 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8897 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8898 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8899 dgst_size = DGST_SIZE_4_5;
8900 parse_func = truecrypt_parse_hash_1k;
8901 sort_by_digest = sort_by_digest_4_5;
8902 opti_type = OPTI_TYPE_ZERO_BYTE;
8903 dgst_pos0 = 0;
8904 dgst_pos1 = 1;
8905 dgst_pos2 = 2;
8906 dgst_pos3 = 3;
8907 break;
8908
8909 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8910 salt_type = SALT_TYPE_EMBEDDED;
8911 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8912 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8913 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8914 dgst_size = DGST_SIZE_4_5;
8915 parse_func = truecrypt_parse_hash_1k;
8916 sort_by_digest = sort_by_digest_4_5;
8917 opti_type = OPTI_TYPE_ZERO_BYTE;
8918 dgst_pos0 = 0;
8919 dgst_pos1 = 1;
8920 dgst_pos2 = 2;
8921 dgst_pos3 = 3;
8922 break;
8923
8924 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8925 salt_type = SALT_TYPE_EMBEDDED;
8926 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8927 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8928 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8929 dgst_size = DGST_SIZE_4_5;
8930 parse_func = truecrypt_parse_hash_1k;
8931 sort_by_digest = sort_by_digest_4_5;
8932 opti_type = OPTI_TYPE_ZERO_BYTE;
8933 dgst_pos0 = 0;
8934 dgst_pos1 = 1;
8935 dgst_pos2 = 2;
8936 dgst_pos3 = 3;
8937 break;
8938
8939 case 6300: hash_type = HASH_TYPE_MD5;
8940 salt_type = SALT_TYPE_EMBEDDED;
8941 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8942 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8943 kern_type = KERN_TYPE_MD5AIX;
8944 dgst_size = DGST_SIZE_4_4;
8945 parse_func = md5aix_parse_hash;
8946 sort_by_digest = sort_by_digest_4_4;
8947 opti_type = OPTI_TYPE_ZERO_BYTE;
8948 dgst_pos0 = 0;
8949 dgst_pos1 = 1;
8950 dgst_pos2 = 2;
8951 dgst_pos3 = 3;
8952 break;
8953
8954 case 6400: hash_type = HASH_TYPE_SHA256;
8955 salt_type = SALT_TYPE_EMBEDDED;
8956 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8957 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8958 kern_type = KERN_TYPE_SHA256AIX;
8959 dgst_size = DGST_SIZE_4_8;
8960 parse_func = sha256aix_parse_hash;
8961 sort_by_digest = sort_by_digest_4_8;
8962 opti_type = OPTI_TYPE_ZERO_BYTE;
8963 dgst_pos0 = 0;
8964 dgst_pos1 = 1;
8965 dgst_pos2 = 2;
8966 dgst_pos3 = 3;
8967 break;
8968
8969 case 6500: hash_type = HASH_TYPE_SHA512;
8970 salt_type = SALT_TYPE_EMBEDDED;
8971 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8972 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8973 kern_type = KERN_TYPE_SHA512AIX;
8974 dgst_size = DGST_SIZE_8_8;
8975 parse_func = sha512aix_parse_hash;
8976 sort_by_digest = sort_by_digest_8_8;
8977 opti_type = OPTI_TYPE_ZERO_BYTE
8978 | OPTI_TYPE_USES_BITS_64;
8979 dgst_pos0 = 0;
8980 dgst_pos1 = 1;
8981 dgst_pos2 = 2;
8982 dgst_pos3 = 3;
8983 break;
8984
8985 case 6600: hash_type = HASH_TYPE_AES;
8986 salt_type = SALT_TYPE_EMBEDDED;
8987 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8988 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8989 kern_type = KERN_TYPE_AGILEKEY;
8990 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8991 parse_func = agilekey_parse_hash;
8992 sort_by_digest = sort_by_digest_4_5;
8993 opti_type = OPTI_TYPE_ZERO_BYTE;
8994 dgst_pos0 = 0;
8995 dgst_pos1 = 1;
8996 dgst_pos2 = 2;
8997 dgst_pos3 = 3;
8998 break;
8999
9000 case 6700: hash_type = HASH_TYPE_SHA1;
9001 salt_type = SALT_TYPE_EMBEDDED;
9002 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9003 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9004 kern_type = KERN_TYPE_SHA1AIX;
9005 dgst_size = DGST_SIZE_4_5;
9006 parse_func = sha1aix_parse_hash;
9007 sort_by_digest = sort_by_digest_4_5;
9008 opti_type = OPTI_TYPE_ZERO_BYTE;
9009 dgst_pos0 = 0;
9010 dgst_pos1 = 1;
9011 dgst_pos2 = 2;
9012 dgst_pos3 = 3;
9013 break;
9014
9015 case 6800: hash_type = HASH_TYPE_AES;
9016 salt_type = SALT_TYPE_EMBEDDED;
9017 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9018 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9019 kern_type = KERN_TYPE_LASTPASS;
9020 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9021 parse_func = lastpass_parse_hash;
9022 sort_by_digest = sort_by_digest_4_8;
9023 opti_type = OPTI_TYPE_ZERO_BYTE;
9024 dgst_pos0 = 0;
9025 dgst_pos1 = 1;
9026 dgst_pos2 = 2;
9027 dgst_pos3 = 3;
9028 break;
9029
9030 case 6900: hash_type = HASH_TYPE_GOST;
9031 salt_type = SALT_TYPE_NONE;
9032 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9033 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9034 kern_type = KERN_TYPE_GOST;
9035 dgst_size = DGST_SIZE_4_8;
9036 parse_func = gost_parse_hash;
9037 sort_by_digest = sort_by_digest_4_8;
9038 opti_type = OPTI_TYPE_ZERO_BYTE;
9039 dgst_pos0 = 0;
9040 dgst_pos1 = 1;
9041 dgst_pos2 = 2;
9042 dgst_pos3 = 3;
9043 break;
9044
9045 case 7100: hash_type = HASH_TYPE_SHA512;
9046 salt_type = SALT_TYPE_EMBEDDED;
9047 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9048 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9049 kern_type = KERN_TYPE_PBKDF2_SHA512;
9050 dgst_size = DGST_SIZE_8_16;
9051 parse_func = sha512osx_parse_hash;
9052 sort_by_digest = sort_by_digest_8_16;
9053 opti_type = OPTI_TYPE_ZERO_BYTE
9054 | OPTI_TYPE_USES_BITS_64;
9055 dgst_pos0 = 0;
9056 dgst_pos1 = 1;
9057 dgst_pos2 = 2;
9058 dgst_pos3 = 3;
9059 break;
9060
9061 case 7200: hash_type = HASH_TYPE_SHA512;
9062 salt_type = SALT_TYPE_EMBEDDED;
9063 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9064 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9065 kern_type = KERN_TYPE_PBKDF2_SHA512;
9066 dgst_size = DGST_SIZE_8_16;
9067 parse_func = sha512grub_parse_hash;
9068 sort_by_digest = sort_by_digest_8_16;
9069 opti_type = OPTI_TYPE_ZERO_BYTE
9070 | OPTI_TYPE_USES_BITS_64;
9071 dgst_pos0 = 0;
9072 dgst_pos1 = 1;
9073 dgst_pos2 = 2;
9074 dgst_pos3 = 3;
9075 break;
9076
9077 case 7300: hash_type = HASH_TYPE_SHA1;
9078 salt_type = SALT_TYPE_EMBEDDED;
9079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9080 opts_type = OPTS_TYPE_PT_GENERATE_BE
9081 | OPTS_TYPE_ST_ADD80
9082 | OPTS_TYPE_ST_ADDBITS15;
9083 kern_type = KERN_TYPE_RAKP;
9084 dgst_size = DGST_SIZE_4_5;
9085 parse_func = rakp_parse_hash;
9086 sort_by_digest = sort_by_digest_4_5;
9087 opti_type = OPTI_TYPE_ZERO_BYTE
9088 | OPTI_TYPE_NOT_ITERATED;
9089 dgst_pos0 = 3;
9090 dgst_pos1 = 4;
9091 dgst_pos2 = 2;
9092 dgst_pos3 = 1;
9093 break;
9094
9095 case 7400: hash_type = HASH_TYPE_SHA256;
9096 salt_type = SALT_TYPE_EMBEDDED;
9097 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9098 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9099 kern_type = KERN_TYPE_SHA256CRYPT;
9100 dgst_size = DGST_SIZE_4_8;
9101 parse_func = sha256crypt_parse_hash;
9102 sort_by_digest = sort_by_digest_4_8;
9103 opti_type = OPTI_TYPE_ZERO_BYTE;
9104 dgst_pos0 = 0;
9105 dgst_pos1 = 1;
9106 dgst_pos2 = 2;
9107 dgst_pos3 = 3;
9108 break;
9109
9110 case 7500: hash_type = HASH_TYPE_KRB5PA;
9111 salt_type = SALT_TYPE_EMBEDDED;
9112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9113 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9114 kern_type = KERN_TYPE_KRB5PA;
9115 dgst_size = DGST_SIZE_4_4;
9116 parse_func = krb5pa_parse_hash;
9117 sort_by_digest = sort_by_digest_4_4;
9118 opti_type = OPTI_TYPE_ZERO_BYTE
9119 | OPTI_TYPE_NOT_ITERATED;
9120 dgst_pos0 = 0;
9121 dgst_pos1 = 1;
9122 dgst_pos2 = 2;
9123 dgst_pos3 = 3;
9124 break;
9125
9126 case 7600: hash_type = HASH_TYPE_SHA1;
9127 salt_type = SALT_TYPE_INTERN;
9128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9129 opts_type = OPTS_TYPE_PT_GENERATE_BE
9130 | OPTS_TYPE_PT_ADD80
9131 | OPTS_TYPE_PT_ADDBITS15;
9132 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9133 dgst_size = DGST_SIZE_4_5;
9134 parse_func = redmine_parse_hash;
9135 sort_by_digest = sort_by_digest_4_5;
9136 opti_type = OPTI_TYPE_ZERO_BYTE
9137 | OPTI_TYPE_PRECOMPUTE_INIT
9138 | OPTI_TYPE_EARLY_SKIP
9139 | OPTI_TYPE_NOT_ITERATED
9140 | OPTI_TYPE_PREPENDED_SALT;
9141 dgst_pos0 = 3;
9142 dgst_pos1 = 4;
9143 dgst_pos2 = 2;
9144 dgst_pos3 = 1;
9145 break;
9146
9147 case 7700: hash_type = HASH_TYPE_SAPB;
9148 salt_type = SALT_TYPE_EMBEDDED;
9149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9150 opts_type = OPTS_TYPE_PT_GENERATE_LE
9151 | OPTS_TYPE_PT_UPPER
9152 | OPTS_TYPE_ST_UPPER;
9153 kern_type = KERN_TYPE_SAPB;
9154 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9155 parse_func = sapb_parse_hash;
9156 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9157 opti_type = OPTI_TYPE_ZERO_BYTE
9158 | OPTI_TYPE_PRECOMPUTE_INIT
9159 | OPTI_TYPE_NOT_ITERATED;
9160 dgst_pos0 = 0;
9161 dgst_pos1 = 1;
9162 dgst_pos2 = 2;
9163 dgst_pos3 = 3;
9164 break;
9165
9166 case 7800: hash_type = HASH_TYPE_SAPG;
9167 salt_type = SALT_TYPE_EMBEDDED;
9168 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9169 opts_type = OPTS_TYPE_PT_GENERATE_BE
9170 | OPTS_TYPE_ST_ADD80
9171 | OPTS_TYPE_ST_UPPER;
9172 kern_type = KERN_TYPE_SAPG;
9173 dgst_size = DGST_SIZE_4_5;
9174 parse_func = sapg_parse_hash;
9175 sort_by_digest = sort_by_digest_4_5;
9176 opti_type = OPTI_TYPE_ZERO_BYTE
9177 | OPTI_TYPE_PRECOMPUTE_INIT
9178 | OPTI_TYPE_NOT_ITERATED;
9179 dgst_pos0 = 3;
9180 dgst_pos1 = 4;
9181 dgst_pos2 = 2;
9182 dgst_pos3 = 1;
9183 break;
9184
9185 case 7900: hash_type = HASH_TYPE_SHA512;
9186 salt_type = SALT_TYPE_EMBEDDED;
9187 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9188 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9189 kern_type = KERN_TYPE_DRUPAL7;
9190 dgst_size = DGST_SIZE_8_8;
9191 parse_func = drupal7_parse_hash;
9192 sort_by_digest = sort_by_digest_8_8;
9193 opti_type = OPTI_TYPE_ZERO_BYTE
9194 | OPTI_TYPE_USES_BITS_64;
9195 dgst_pos0 = 0;
9196 dgst_pos1 = 1;
9197 dgst_pos2 = 2;
9198 dgst_pos3 = 3;
9199 break;
9200
9201 case 8000: hash_type = HASH_TYPE_SHA256;
9202 salt_type = SALT_TYPE_EMBEDDED;
9203 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9204 opts_type = OPTS_TYPE_PT_GENERATE_BE
9205 | OPTS_TYPE_PT_UNICODE
9206 | OPTS_TYPE_ST_ADD80
9207 | OPTS_TYPE_ST_HEX;
9208 kern_type = KERN_TYPE_SYBASEASE;
9209 dgst_size = DGST_SIZE_4_8;
9210 parse_func = sybasease_parse_hash;
9211 sort_by_digest = sort_by_digest_4_8;
9212 opti_type = OPTI_TYPE_ZERO_BYTE
9213 | OPTI_TYPE_PRECOMPUTE_INIT
9214 | OPTI_TYPE_EARLY_SKIP
9215 | OPTI_TYPE_NOT_ITERATED
9216 | OPTI_TYPE_RAW_HASH;
9217 dgst_pos0 = 3;
9218 dgst_pos1 = 7;
9219 dgst_pos2 = 2;
9220 dgst_pos3 = 6;
9221 break;
9222
9223 case 8100: hash_type = HASH_TYPE_SHA1;
9224 salt_type = SALT_TYPE_EMBEDDED;
9225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9226 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9227 kern_type = KERN_TYPE_NETSCALER;
9228 dgst_size = DGST_SIZE_4_5;
9229 parse_func = netscaler_parse_hash;
9230 sort_by_digest = sort_by_digest_4_5;
9231 opti_type = OPTI_TYPE_ZERO_BYTE
9232 | OPTI_TYPE_PRECOMPUTE_INIT
9233 | OPTI_TYPE_PRECOMPUTE_MERKLE
9234 | OPTI_TYPE_EARLY_SKIP
9235 | OPTI_TYPE_NOT_ITERATED
9236 | OPTI_TYPE_PREPENDED_SALT
9237 | OPTI_TYPE_RAW_HASH;
9238 dgst_pos0 = 3;
9239 dgst_pos1 = 4;
9240 dgst_pos2 = 2;
9241 dgst_pos3 = 1;
9242 break;
9243
9244 case 8200: hash_type = HASH_TYPE_SHA256;
9245 salt_type = SALT_TYPE_EMBEDDED;
9246 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9247 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9248 kern_type = KERN_TYPE_CLOUDKEY;
9249 dgst_size = DGST_SIZE_4_8;
9250 parse_func = cloudkey_parse_hash;
9251 sort_by_digest = sort_by_digest_4_8;
9252 opti_type = OPTI_TYPE_ZERO_BYTE;
9253 dgst_pos0 = 0;
9254 dgst_pos1 = 1;
9255 dgst_pos2 = 2;
9256 dgst_pos3 = 3;
9257 break;
9258
9259 case 8300: hash_type = HASH_TYPE_SHA1;
9260 salt_type = SALT_TYPE_EMBEDDED;
9261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9262 opts_type = OPTS_TYPE_PT_GENERATE_LE
9263 | OPTS_TYPE_ST_HEX
9264 | OPTS_TYPE_ST_ADD80;
9265 kern_type = KERN_TYPE_NSEC3;
9266 dgst_size = DGST_SIZE_4_5;
9267 parse_func = nsec3_parse_hash;
9268 sort_by_digest = sort_by_digest_4_5;
9269 opti_type = OPTI_TYPE_ZERO_BYTE;
9270 dgst_pos0 = 3;
9271 dgst_pos1 = 4;
9272 dgst_pos2 = 2;
9273 dgst_pos3 = 1;
9274 break;
9275
9276 case 8400: hash_type = HASH_TYPE_SHA1;
9277 salt_type = SALT_TYPE_INTERN;
9278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9279 opts_type = OPTS_TYPE_PT_GENERATE_BE
9280 | OPTS_TYPE_PT_ADD80
9281 | OPTS_TYPE_PT_ADDBITS15;
9282 kern_type = KERN_TYPE_WBB3;
9283 dgst_size = DGST_SIZE_4_5;
9284 parse_func = wbb3_parse_hash;
9285 sort_by_digest = sort_by_digest_4_5;
9286 opti_type = OPTI_TYPE_ZERO_BYTE
9287 | OPTI_TYPE_PRECOMPUTE_INIT
9288 | OPTI_TYPE_NOT_ITERATED;
9289 dgst_pos0 = 3;
9290 dgst_pos1 = 4;
9291 dgst_pos2 = 2;
9292 dgst_pos3 = 1;
9293 break;
9294
9295 case 8500: hash_type = HASH_TYPE_DESRACF;
9296 salt_type = SALT_TYPE_EMBEDDED;
9297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9298 opts_type = OPTS_TYPE_PT_GENERATE_LE
9299 | OPTS_TYPE_ST_UPPER;
9300 kern_type = KERN_TYPE_RACF;
9301 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9302 parse_func = racf_parse_hash;
9303 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9304 opti_type = OPTI_TYPE_ZERO_BYTE
9305 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9306 dgst_pos0 = 0;
9307 dgst_pos1 = 1;
9308 dgst_pos2 = 2;
9309 dgst_pos3 = 3;
9310 break;
9311
9312 case 8600: hash_type = HASH_TYPE_LOTUS5;
9313 salt_type = SALT_TYPE_NONE;
9314 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9315 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9316 kern_type = KERN_TYPE_LOTUS5;
9317 dgst_size = DGST_SIZE_4_4;
9318 parse_func = lotus5_parse_hash;
9319 sort_by_digest = sort_by_digest_4_4;
9320 opti_type = OPTI_TYPE_EARLY_SKIP
9321 | OPTI_TYPE_NOT_ITERATED
9322 | OPTI_TYPE_NOT_SALTED
9323 | OPTI_TYPE_RAW_HASH;
9324 dgst_pos0 = 0;
9325 dgst_pos1 = 1;
9326 dgst_pos2 = 2;
9327 dgst_pos3 = 3;
9328 break;
9329
9330 case 8700: hash_type = HASH_TYPE_LOTUS6;
9331 salt_type = SALT_TYPE_EMBEDDED;
9332 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9333 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9334 kern_type = KERN_TYPE_LOTUS6;
9335 dgst_size = DGST_SIZE_4_4;
9336 parse_func = lotus6_parse_hash;
9337 sort_by_digest = sort_by_digest_4_4;
9338 opti_type = OPTI_TYPE_EARLY_SKIP
9339 | OPTI_TYPE_NOT_ITERATED
9340 | OPTI_TYPE_RAW_HASH;
9341 dgst_pos0 = 0;
9342 dgst_pos1 = 1;
9343 dgst_pos2 = 2;
9344 dgst_pos3 = 3;
9345 break;
9346
9347 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9348 salt_type = SALT_TYPE_EMBEDDED;
9349 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9350 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9351 kern_type = KERN_TYPE_ANDROIDFDE;
9352 dgst_size = DGST_SIZE_4_4;
9353 parse_func = androidfde_parse_hash;
9354 sort_by_digest = sort_by_digest_4_4;
9355 opti_type = OPTI_TYPE_ZERO_BYTE;
9356 dgst_pos0 = 0;
9357 dgst_pos1 = 1;
9358 dgst_pos2 = 2;
9359 dgst_pos3 = 3;
9360 break;
9361
9362 case 8900: hash_type = HASH_TYPE_SCRYPT;
9363 salt_type = SALT_TYPE_EMBEDDED;
9364 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9365 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9366 kern_type = KERN_TYPE_SCRYPT;
9367 dgst_size = DGST_SIZE_4_8;
9368 parse_func = scrypt_parse_hash;
9369 sort_by_digest = sort_by_digest_4_8;
9370 opti_type = OPTI_TYPE_ZERO_BYTE;
9371 dgst_pos0 = 0;
9372 dgst_pos1 = 1;
9373 dgst_pos2 = 2;
9374 dgst_pos3 = 3;
9375 break;
9376
9377 case 9000: hash_type = HASH_TYPE_SHA1;
9378 salt_type = SALT_TYPE_EMBEDDED;
9379 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9380 opts_type = OPTS_TYPE_PT_GENERATE_LE
9381 | OPTS_TYPE_ST_GENERATE_LE;
9382 kern_type = KERN_TYPE_PSAFE2;
9383 dgst_size = DGST_SIZE_4_5;
9384 parse_func = psafe2_parse_hash;
9385 sort_by_digest = sort_by_digest_4_5;
9386 opti_type = OPTI_TYPE_ZERO_BYTE;
9387 dgst_pos0 = 0;
9388 dgst_pos1 = 1;
9389 dgst_pos2 = 2;
9390 dgst_pos3 = 3;
9391 break;
9392
9393 case 9100: hash_type = HASH_TYPE_LOTUS8;
9394 salt_type = SALT_TYPE_EMBEDDED;
9395 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9396 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9397 kern_type = KERN_TYPE_LOTUS8;
9398 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9399 parse_func = lotus8_parse_hash;
9400 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9401 opti_type = OPTI_TYPE_ZERO_BYTE;
9402 dgst_pos0 = 0;
9403 dgst_pos1 = 1;
9404 dgst_pos2 = 2;
9405 dgst_pos3 = 3;
9406 break;
9407
9408 case 9200: hash_type = HASH_TYPE_SHA256;
9409 salt_type = SALT_TYPE_EMBEDDED;
9410 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9411 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9412 kern_type = KERN_TYPE_PBKDF2_SHA256;
9413 dgst_size = DGST_SIZE_4_32;
9414 parse_func = cisco8_parse_hash;
9415 sort_by_digest = sort_by_digest_4_32;
9416 opti_type = OPTI_TYPE_ZERO_BYTE;
9417 dgst_pos0 = 0;
9418 dgst_pos1 = 1;
9419 dgst_pos2 = 2;
9420 dgst_pos3 = 3;
9421 break;
9422
9423 case 9300: hash_type = HASH_TYPE_SCRYPT;
9424 salt_type = SALT_TYPE_EMBEDDED;
9425 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9426 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9427 kern_type = KERN_TYPE_SCRYPT;
9428 dgst_size = DGST_SIZE_4_8;
9429 parse_func = cisco9_parse_hash;
9430 sort_by_digest = sort_by_digest_4_8;
9431 opti_type = OPTI_TYPE_ZERO_BYTE;
9432 dgst_pos0 = 0;
9433 dgst_pos1 = 1;
9434 dgst_pos2 = 2;
9435 dgst_pos3 = 3;
9436 break;
9437
9438 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9439 salt_type = SALT_TYPE_EMBEDDED;
9440 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9441 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9442 kern_type = KERN_TYPE_OFFICE2007;
9443 dgst_size = DGST_SIZE_4_4;
9444 parse_func = office2007_parse_hash;
9445 sort_by_digest = sort_by_digest_4_4;
9446 opti_type = OPTI_TYPE_ZERO_BYTE;
9447 dgst_pos0 = 0;
9448 dgst_pos1 = 1;
9449 dgst_pos2 = 2;
9450 dgst_pos3 = 3;
9451 break;
9452
9453 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9454 salt_type = SALT_TYPE_EMBEDDED;
9455 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9456 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9457 kern_type = KERN_TYPE_OFFICE2010;
9458 dgst_size = DGST_SIZE_4_4;
9459 parse_func = office2010_parse_hash;
9460 sort_by_digest = sort_by_digest_4_4;
9461 opti_type = OPTI_TYPE_ZERO_BYTE;
9462 dgst_pos0 = 0;
9463 dgst_pos1 = 1;
9464 dgst_pos2 = 2;
9465 dgst_pos3 = 3;
9466 break;
9467
9468 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9469 salt_type = SALT_TYPE_EMBEDDED;
9470 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9471 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9472 kern_type = KERN_TYPE_OFFICE2013;
9473 dgst_size = DGST_SIZE_4_4;
9474 parse_func = office2013_parse_hash;
9475 sort_by_digest = sort_by_digest_4_4;
9476 opti_type = OPTI_TYPE_ZERO_BYTE;
9477 dgst_pos0 = 0;
9478 dgst_pos1 = 1;
9479 dgst_pos2 = 2;
9480 dgst_pos3 = 3;
9481 break;
9482
9483 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9484 salt_type = SALT_TYPE_EMBEDDED;
9485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9486 opts_type = OPTS_TYPE_PT_GENERATE_LE
9487 | OPTS_TYPE_PT_ADD80
9488 | OPTS_TYPE_PT_UNICODE;
9489 kern_type = KERN_TYPE_OLDOFFICE01;
9490 dgst_size = DGST_SIZE_4_4;
9491 parse_func = oldoffice01_parse_hash;
9492 sort_by_digest = sort_by_digest_4_4;
9493 opti_type = OPTI_TYPE_ZERO_BYTE
9494 | OPTI_TYPE_PRECOMPUTE_INIT
9495 | OPTI_TYPE_NOT_ITERATED;
9496 dgst_pos0 = 0;
9497 dgst_pos1 = 1;
9498 dgst_pos2 = 2;
9499 dgst_pos3 = 3;
9500 break;
9501
9502 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9503 salt_type = SALT_TYPE_EMBEDDED;
9504 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9505 opts_type = OPTS_TYPE_PT_GENERATE_LE
9506 | OPTS_TYPE_PT_ADD80;
9507 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9508 dgst_size = DGST_SIZE_4_4;
9509 parse_func = oldoffice01cm1_parse_hash;
9510 sort_by_digest = sort_by_digest_4_4;
9511 opti_type = OPTI_TYPE_ZERO_BYTE
9512 | OPTI_TYPE_PRECOMPUTE_INIT
9513 | OPTI_TYPE_NOT_ITERATED;
9514 dgst_pos0 = 0;
9515 dgst_pos1 = 1;
9516 dgst_pos2 = 2;
9517 dgst_pos3 = 3;
9518 break;
9519
9520 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9521 salt_type = SALT_TYPE_EMBEDDED;
9522 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9523 opts_type = OPTS_TYPE_PT_GENERATE_LE
9524 | OPTS_TYPE_PT_ADD80
9525 | OPTS_TYPE_PT_UNICODE
9526 | OPTS_TYPE_PT_NEVERCRACK;
9527 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9528 dgst_size = DGST_SIZE_4_4;
9529 parse_func = oldoffice01cm2_parse_hash;
9530 sort_by_digest = sort_by_digest_4_4;
9531 opti_type = OPTI_TYPE_ZERO_BYTE
9532 | OPTI_TYPE_PRECOMPUTE_INIT
9533 | OPTI_TYPE_NOT_ITERATED;
9534 dgst_pos0 = 0;
9535 dgst_pos1 = 1;
9536 dgst_pos2 = 2;
9537 dgst_pos3 = 3;
9538 break;
9539
9540 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9541 salt_type = SALT_TYPE_EMBEDDED;
9542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9543 opts_type = OPTS_TYPE_PT_GENERATE_BE
9544 | OPTS_TYPE_PT_ADD80
9545 | OPTS_TYPE_PT_UNICODE;
9546 kern_type = KERN_TYPE_OLDOFFICE34;
9547 dgst_size = DGST_SIZE_4_4;
9548 parse_func = oldoffice34_parse_hash;
9549 sort_by_digest = sort_by_digest_4_4;
9550 opti_type = OPTI_TYPE_ZERO_BYTE
9551 | OPTI_TYPE_PRECOMPUTE_INIT
9552 | OPTI_TYPE_NOT_ITERATED;
9553 dgst_pos0 = 0;
9554 dgst_pos1 = 1;
9555 dgst_pos2 = 2;
9556 dgst_pos3 = 3;
9557 break;
9558
9559 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9560 salt_type = SALT_TYPE_EMBEDDED;
9561 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9562 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9563 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9564 dgst_size = DGST_SIZE_4_4;
9565 parse_func = oldoffice34cm1_parse_hash;
9566 sort_by_digest = sort_by_digest_4_4;
9567 opti_type = OPTI_TYPE_ZERO_BYTE
9568 | OPTI_TYPE_PRECOMPUTE_INIT
9569 | OPTI_TYPE_NOT_ITERATED;
9570 dgst_pos0 = 0;
9571 dgst_pos1 = 1;
9572 dgst_pos2 = 2;
9573 dgst_pos3 = 3;
9574 break;
9575
9576 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9577 salt_type = SALT_TYPE_EMBEDDED;
9578 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9579 opts_type = OPTS_TYPE_PT_GENERATE_BE
9580 | OPTS_TYPE_PT_ADD80
9581 | OPTS_TYPE_PT_UNICODE
9582 | OPTS_TYPE_PT_NEVERCRACK;
9583 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9584 dgst_size = DGST_SIZE_4_4;
9585 parse_func = oldoffice34cm2_parse_hash;
9586 sort_by_digest = sort_by_digest_4_4;
9587 opti_type = OPTI_TYPE_ZERO_BYTE
9588 | OPTI_TYPE_PRECOMPUTE_INIT
9589 | OPTI_TYPE_NOT_ITERATED;
9590 dgst_pos0 = 0;
9591 dgst_pos1 = 1;
9592 dgst_pos2 = 2;
9593 dgst_pos3 = 3;
9594 break;
9595
9596 case 9900: hash_type = HASH_TYPE_MD5;
9597 salt_type = SALT_TYPE_NONE;
9598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9599 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9600 kern_type = KERN_TYPE_RADMIN2;
9601 dgst_size = DGST_SIZE_4_4;
9602 parse_func = radmin2_parse_hash;
9603 sort_by_digest = sort_by_digest_4_4;
9604 opti_type = OPTI_TYPE_ZERO_BYTE
9605 | OPTI_TYPE_PRECOMPUTE_INIT
9606 | OPTI_TYPE_EARLY_SKIP
9607 | OPTI_TYPE_NOT_ITERATED
9608 | OPTI_TYPE_NOT_SALTED;
9609 dgst_pos0 = 0;
9610 dgst_pos1 = 3;
9611 dgst_pos2 = 2;
9612 dgst_pos3 = 1;
9613 break;
9614
9615 case 10000: hash_type = HASH_TYPE_SHA256;
9616 salt_type = SALT_TYPE_EMBEDDED;
9617 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9618 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9619 kern_type = KERN_TYPE_PBKDF2_SHA256;
9620 dgst_size = DGST_SIZE_4_32;
9621 parse_func = djangopbkdf2_parse_hash;
9622 sort_by_digest = sort_by_digest_4_32;
9623 opti_type = OPTI_TYPE_ZERO_BYTE;
9624 dgst_pos0 = 0;
9625 dgst_pos1 = 1;
9626 dgst_pos2 = 2;
9627 dgst_pos3 = 3;
9628 break;
9629
9630 case 10100: hash_type = HASH_TYPE_SIPHASH;
9631 salt_type = SALT_TYPE_EMBEDDED;
9632 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9633 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9634 kern_type = KERN_TYPE_SIPHASH;
9635 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9636 parse_func = siphash_parse_hash;
9637 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9638 opti_type = OPTI_TYPE_ZERO_BYTE
9639 | OPTI_TYPE_NOT_ITERATED
9640 | OPTI_TYPE_RAW_HASH;
9641 dgst_pos0 = 0;
9642 dgst_pos1 = 1;
9643 dgst_pos2 = 2;
9644 dgst_pos3 = 3;
9645 break;
9646
9647 case 10200: hash_type = HASH_TYPE_MD5;
9648 salt_type = SALT_TYPE_EMBEDDED;
9649 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9650 opts_type = OPTS_TYPE_PT_GENERATE_LE
9651 | OPTS_TYPE_ST_ADD80
9652 | OPTS_TYPE_ST_ADDBITS14;
9653 kern_type = KERN_TYPE_HMACMD5_PW;
9654 dgst_size = DGST_SIZE_4_4;
9655 parse_func = crammd5_parse_hash;
9656 sort_by_digest = sort_by_digest_4_4;
9657 opti_type = OPTI_TYPE_ZERO_BYTE
9658 | OPTI_TYPE_NOT_ITERATED;
9659 dgst_pos0 = 0;
9660 dgst_pos1 = 3;
9661 dgst_pos2 = 2;
9662 dgst_pos3 = 1;
9663 break;
9664
9665 case 10300: hash_type = HASH_TYPE_SHA1;
9666 salt_type = SALT_TYPE_EMBEDDED;
9667 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9668 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9669 kern_type = KERN_TYPE_SAPH_SHA1;
9670 dgst_size = DGST_SIZE_4_5;
9671 parse_func = saph_sha1_parse_hash;
9672 sort_by_digest = sort_by_digest_4_5;
9673 opti_type = OPTI_TYPE_ZERO_BYTE;
9674 dgst_pos0 = 0;
9675 dgst_pos1 = 1;
9676 dgst_pos2 = 2;
9677 dgst_pos3 = 3;
9678 break;
9679
9680 case 10400: hash_type = HASH_TYPE_PDFU16;
9681 salt_type = SALT_TYPE_EMBEDDED;
9682 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9683 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9684 kern_type = KERN_TYPE_PDF11;
9685 dgst_size = DGST_SIZE_4_4;
9686 parse_func = pdf11_parse_hash;
9687 sort_by_digest = sort_by_digest_4_4;
9688 opti_type = OPTI_TYPE_ZERO_BYTE
9689 | OPTI_TYPE_NOT_ITERATED;
9690 dgst_pos0 = 0;
9691 dgst_pos1 = 1;
9692 dgst_pos2 = 2;
9693 dgst_pos3 = 3;
9694 break;
9695
9696 case 10410: hash_type = HASH_TYPE_PDFU16;
9697 salt_type = SALT_TYPE_EMBEDDED;
9698 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9699 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9700 kern_type = KERN_TYPE_PDF11CM1;
9701 dgst_size = DGST_SIZE_4_4;
9702 parse_func = pdf11cm1_parse_hash;
9703 sort_by_digest = sort_by_digest_4_4;
9704 opti_type = OPTI_TYPE_ZERO_BYTE
9705 | OPTI_TYPE_NOT_ITERATED;
9706 dgst_pos0 = 0;
9707 dgst_pos1 = 1;
9708 dgst_pos2 = 2;
9709 dgst_pos3 = 3;
9710 break;
9711
9712 case 10420: hash_type = HASH_TYPE_PDFU16;
9713 salt_type = SALT_TYPE_EMBEDDED;
9714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9715 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9716 kern_type = KERN_TYPE_PDF11CM2;
9717 dgst_size = DGST_SIZE_4_4;
9718 parse_func = pdf11cm2_parse_hash;
9719 sort_by_digest = sort_by_digest_4_4;
9720 opti_type = OPTI_TYPE_ZERO_BYTE
9721 | OPTI_TYPE_NOT_ITERATED;
9722 dgst_pos0 = 0;
9723 dgst_pos1 = 1;
9724 dgst_pos2 = 2;
9725 dgst_pos3 = 3;
9726 break;
9727
9728 case 10500: hash_type = HASH_TYPE_PDFU16;
9729 salt_type = SALT_TYPE_EMBEDDED;
9730 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9731 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9732 kern_type = KERN_TYPE_PDF14;
9733 dgst_size = DGST_SIZE_4_4;
9734 parse_func = pdf14_parse_hash;
9735 sort_by_digest = sort_by_digest_4_4;
9736 opti_type = OPTI_TYPE_ZERO_BYTE
9737 | OPTI_TYPE_NOT_ITERATED;
9738 dgst_pos0 = 0;
9739 dgst_pos1 = 1;
9740 dgst_pos2 = 2;
9741 dgst_pos3 = 3;
9742 break;
9743
9744 case 10600: hash_type = HASH_TYPE_SHA256;
9745 salt_type = SALT_TYPE_EMBEDDED;
9746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9747 opts_type = OPTS_TYPE_PT_GENERATE_BE
9748 | OPTS_TYPE_ST_ADD80
9749 | OPTS_TYPE_ST_ADDBITS15
9750 | OPTS_TYPE_HASH_COPY;
9751 kern_type = KERN_TYPE_SHA256_PWSLT;
9752 dgst_size = DGST_SIZE_4_8;
9753 parse_func = pdf17l3_parse_hash;
9754 sort_by_digest = sort_by_digest_4_8;
9755 opti_type = OPTI_TYPE_ZERO_BYTE
9756 | OPTI_TYPE_PRECOMPUTE_INIT
9757 | OPTI_TYPE_PRECOMPUTE_MERKLE
9758 | OPTI_TYPE_EARLY_SKIP
9759 | OPTI_TYPE_NOT_ITERATED
9760 | OPTI_TYPE_APPENDED_SALT
9761 | OPTI_TYPE_RAW_HASH;
9762 dgst_pos0 = 3;
9763 dgst_pos1 = 7;
9764 dgst_pos2 = 2;
9765 dgst_pos3 = 6;
9766 break;
9767
9768 case 10700: hash_type = HASH_TYPE_PDFU32;
9769 salt_type = SALT_TYPE_EMBEDDED;
9770 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9771 opts_type = OPTS_TYPE_PT_GENERATE_LE
9772 | OPTS_TYPE_HASH_COPY;
9773 kern_type = KERN_TYPE_PDF17L8;
9774 dgst_size = DGST_SIZE_4_8;
9775 parse_func = pdf17l8_parse_hash;
9776 sort_by_digest = sort_by_digest_4_8;
9777 opti_type = OPTI_TYPE_ZERO_BYTE
9778 | OPTI_TYPE_NOT_ITERATED;
9779 dgst_pos0 = 0;
9780 dgst_pos1 = 1;
9781 dgst_pos2 = 2;
9782 dgst_pos3 = 3;
9783 break;
9784
9785 case 10800: hash_type = HASH_TYPE_SHA384;
9786 salt_type = SALT_TYPE_NONE;
9787 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9788 opts_type = OPTS_TYPE_PT_GENERATE_BE
9789 | OPTS_TYPE_PT_ADD80
9790 | OPTS_TYPE_PT_ADDBITS15;
9791 kern_type = KERN_TYPE_SHA384;
9792 dgst_size = DGST_SIZE_8_8;
9793 parse_func = sha384_parse_hash;
9794 sort_by_digest = sort_by_digest_8_8;
9795 opti_type = OPTI_TYPE_ZERO_BYTE
9796 | OPTI_TYPE_PRECOMPUTE_INIT
9797 | OPTI_TYPE_PRECOMPUTE_MERKLE
9798 | OPTI_TYPE_EARLY_SKIP
9799 | OPTI_TYPE_NOT_ITERATED
9800 | OPTI_TYPE_NOT_SALTED
9801 | OPTI_TYPE_USES_BITS_64
9802 | OPTI_TYPE_RAW_HASH;
9803 dgst_pos0 = 6;
9804 dgst_pos1 = 7;
9805 dgst_pos2 = 4;
9806 dgst_pos3 = 5;
9807 break;
9808
9809 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9810 salt_type = SALT_TYPE_EMBEDDED;
9811 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9812 opts_type = OPTS_TYPE_PT_GENERATE_LE
9813 | OPTS_TYPE_ST_BASE64
9814 | OPTS_TYPE_HASH_COPY;
9815 kern_type = KERN_TYPE_PBKDF2_SHA256;
9816 dgst_size = DGST_SIZE_4_32;
9817 parse_func = pbkdf2_sha256_parse_hash;
9818 sort_by_digest = sort_by_digest_4_32;
9819 opti_type = OPTI_TYPE_ZERO_BYTE;
9820 dgst_pos0 = 0;
9821 dgst_pos1 = 1;
9822 dgst_pos2 = 2;
9823 dgst_pos3 = 3;
9824 break;
9825
9826 case 11000: hash_type = HASH_TYPE_MD5;
9827 salt_type = SALT_TYPE_INTERN;
9828 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9829 opts_type = OPTS_TYPE_PT_GENERATE_LE
9830 | OPTS_TYPE_PT_ADD80;
9831 kern_type = KERN_TYPE_PRESTASHOP;
9832 dgst_size = DGST_SIZE_4_4;
9833 parse_func = prestashop_parse_hash;
9834 sort_by_digest = sort_by_digest_4_4;
9835 opti_type = OPTI_TYPE_ZERO_BYTE
9836 | OPTI_TYPE_PRECOMPUTE_INIT
9837 | OPTI_TYPE_NOT_ITERATED
9838 | OPTI_TYPE_PREPENDED_SALT;
9839 dgst_pos0 = 0;
9840 dgst_pos1 = 3;
9841 dgst_pos2 = 2;
9842 dgst_pos3 = 1;
9843 break;
9844
9845 case 11100: hash_type = HASH_TYPE_MD5;
9846 salt_type = SALT_TYPE_EMBEDDED;
9847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9848 opts_type = OPTS_TYPE_PT_GENERATE_LE
9849 | OPTS_TYPE_ST_ADD80;
9850 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9851 dgst_size = DGST_SIZE_4_4;
9852 parse_func = postgresql_auth_parse_hash;
9853 sort_by_digest = sort_by_digest_4_4;
9854 opti_type = OPTI_TYPE_ZERO_BYTE
9855 | OPTI_TYPE_PRECOMPUTE_INIT
9856 | OPTI_TYPE_PRECOMPUTE_MERKLE
9857 | OPTI_TYPE_EARLY_SKIP;
9858 dgst_pos0 = 0;
9859 dgst_pos1 = 3;
9860 dgst_pos2 = 2;
9861 dgst_pos3 = 1;
9862 break;
9863
9864 case 11200: hash_type = HASH_TYPE_SHA1;
9865 salt_type = SALT_TYPE_EMBEDDED;
9866 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9867 opts_type = OPTS_TYPE_PT_GENERATE_BE
9868 | OPTS_TYPE_PT_ADD80
9869 | OPTS_TYPE_ST_HEX;
9870 kern_type = KERN_TYPE_MYSQL_AUTH;
9871 dgst_size = DGST_SIZE_4_5;
9872 parse_func = mysql_auth_parse_hash;
9873 sort_by_digest = sort_by_digest_4_5;
9874 opti_type = OPTI_TYPE_ZERO_BYTE
9875 | OPTI_TYPE_EARLY_SKIP;
9876 dgst_pos0 = 3;
9877 dgst_pos1 = 4;
9878 dgst_pos2 = 2;
9879 dgst_pos3 = 1;
9880 break;
9881
9882 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9883 salt_type = SALT_TYPE_EMBEDDED;
9884 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9885 opts_type = OPTS_TYPE_PT_GENERATE_LE
9886 | OPTS_TYPE_ST_HEX
9887 | OPTS_TYPE_ST_ADD80;
9888 kern_type = KERN_TYPE_BITCOIN_WALLET;
9889 dgst_size = DGST_SIZE_4_4;
9890 parse_func = bitcoin_wallet_parse_hash;
9891 sort_by_digest = sort_by_digest_4_4;
9892 opti_type = OPTI_TYPE_ZERO_BYTE;
9893 dgst_pos0 = 0;
9894 dgst_pos1 = 1;
9895 dgst_pos2 = 2;
9896 dgst_pos3 = 3;
9897 break;
9898
9899 case 11400: hash_type = HASH_TYPE_MD5;
9900 salt_type = SALT_TYPE_EMBEDDED;
9901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9902 opts_type = OPTS_TYPE_PT_GENERATE_LE
9903 | OPTS_TYPE_PT_ADD80
9904 | OPTS_TYPE_HASH_COPY;
9905 kern_type = KERN_TYPE_SIP_AUTH;
9906 dgst_size = DGST_SIZE_4_4;
9907 parse_func = sip_auth_parse_hash;
9908 sort_by_digest = sort_by_digest_4_4;
9909 opti_type = OPTI_TYPE_ZERO_BYTE;
9910 dgst_pos0 = 0;
9911 dgst_pos1 = 3;
9912 dgst_pos2 = 2;
9913 dgst_pos3 = 1;
9914 break;
9915
9916 case 11500: hash_type = HASH_TYPE_CRC32;
9917 salt_type = SALT_TYPE_INTERN;
9918 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9919 opts_type = OPTS_TYPE_PT_GENERATE_LE
9920 | OPTS_TYPE_ST_GENERATE_LE
9921 | OPTS_TYPE_ST_HEX;
9922 kern_type = KERN_TYPE_CRC32;
9923 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9924 parse_func = crc32_parse_hash;
9925 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9926 opti_type = OPTI_TYPE_ZERO_BYTE;
9927 dgst_pos0 = 0;
9928 dgst_pos1 = 1;
9929 dgst_pos2 = 2;
9930 dgst_pos3 = 3;
9931 break;
9932
9933 case 11600: hash_type = HASH_TYPE_AES;
9934 salt_type = SALT_TYPE_EMBEDDED;
9935 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9936 opts_type = OPTS_TYPE_PT_GENERATE_LE
9937 | OPTS_TYPE_PT_NEVERCRACK;
9938 kern_type = KERN_TYPE_SEVEN_ZIP;
9939 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9940 parse_func = seven_zip_parse_hash;
9941 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9942 opti_type = OPTI_TYPE_ZERO_BYTE;
9943 dgst_pos0 = 0;
9944 dgst_pos1 = 1;
9945 dgst_pos2 = 2;
9946 dgst_pos3 = 3;
9947 break;
9948
9949 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9950 salt_type = SALT_TYPE_NONE;
9951 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9952 opts_type = OPTS_TYPE_PT_GENERATE_LE
9953 | OPTS_TYPE_PT_ADD01;
9954 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9955 dgst_size = DGST_SIZE_4_8;
9956 parse_func = gost2012sbog_256_parse_hash;
9957 sort_by_digest = sort_by_digest_4_8;
9958 opti_type = OPTI_TYPE_ZERO_BYTE;
9959 dgst_pos0 = 0;
9960 dgst_pos1 = 1;
9961 dgst_pos2 = 2;
9962 dgst_pos3 = 3;
9963 break;
9964
9965 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9966 salt_type = SALT_TYPE_NONE;
9967 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9968 opts_type = OPTS_TYPE_PT_GENERATE_LE
9969 | OPTS_TYPE_PT_ADD01;
9970 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9971 dgst_size = DGST_SIZE_4_16;
9972 parse_func = gost2012sbog_512_parse_hash;
9973 sort_by_digest = sort_by_digest_4_16;
9974 opti_type = OPTI_TYPE_ZERO_BYTE;
9975 dgst_pos0 = 0;
9976 dgst_pos1 = 1;
9977 dgst_pos2 = 2;
9978 dgst_pos3 = 3;
9979 break;
9980
9981 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9982 salt_type = SALT_TYPE_EMBEDDED;
9983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9984 opts_type = OPTS_TYPE_PT_GENERATE_LE
9985 | OPTS_TYPE_ST_BASE64
9986 | OPTS_TYPE_HASH_COPY;
9987 kern_type = KERN_TYPE_PBKDF2_MD5;
9988 dgst_size = DGST_SIZE_4_32;
9989 parse_func = pbkdf2_md5_parse_hash;
9990 sort_by_digest = sort_by_digest_4_32;
9991 opti_type = OPTI_TYPE_ZERO_BYTE;
9992 dgst_pos0 = 0;
9993 dgst_pos1 = 1;
9994 dgst_pos2 = 2;
9995 dgst_pos3 = 3;
9996 break;
9997
9998 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9999 salt_type = SALT_TYPE_EMBEDDED;
10000 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10001 opts_type = OPTS_TYPE_PT_GENERATE_LE
10002 | OPTS_TYPE_ST_BASE64
10003 | OPTS_TYPE_HASH_COPY;
10004 kern_type = KERN_TYPE_PBKDF2_SHA1;
10005 dgst_size = DGST_SIZE_4_32;
10006 parse_func = pbkdf2_sha1_parse_hash;
10007 sort_by_digest = sort_by_digest_4_32;
10008 opti_type = OPTI_TYPE_ZERO_BYTE;
10009 dgst_pos0 = 0;
10010 dgst_pos1 = 1;
10011 dgst_pos2 = 2;
10012 dgst_pos3 = 3;
10013 break;
10014
10015 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10016 salt_type = SALT_TYPE_EMBEDDED;
10017 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10018 opts_type = OPTS_TYPE_PT_GENERATE_LE
10019 | OPTS_TYPE_ST_BASE64
10020 | OPTS_TYPE_HASH_COPY;
10021 kern_type = KERN_TYPE_PBKDF2_SHA512;
10022 dgst_size = DGST_SIZE_8_16;
10023 parse_func = pbkdf2_sha512_parse_hash;
10024 sort_by_digest = sort_by_digest_8_16;
10025 opti_type = OPTI_TYPE_ZERO_BYTE
10026 | OPTI_TYPE_USES_BITS_64;
10027 dgst_pos0 = 0;
10028 dgst_pos1 = 1;
10029 dgst_pos2 = 2;
10030 dgst_pos3 = 3;
10031 break;
10032
10033 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10034 salt_type = SALT_TYPE_EMBEDDED;
10035 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10036 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10037 kern_type = KERN_TYPE_ECRYPTFS;
10038 dgst_size = DGST_SIZE_8_8;
10039 parse_func = ecryptfs_parse_hash;
10040 sort_by_digest = sort_by_digest_8_8;
10041 opti_type = OPTI_TYPE_ZERO_BYTE
10042 | OPTI_TYPE_USES_BITS_64;
10043 dgst_pos0 = 0;
10044 dgst_pos1 = 1;
10045 dgst_pos2 = 2;
10046 dgst_pos3 = 3;
10047 break;
10048
10049 case 12300: hash_type = HASH_TYPE_ORACLET;
10050 salt_type = SALT_TYPE_EMBEDDED;
10051 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10052 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10053 kern_type = KERN_TYPE_ORACLET;
10054 dgst_size = DGST_SIZE_8_16;
10055 parse_func = oraclet_parse_hash;
10056 sort_by_digest = sort_by_digest_8_16;
10057 opti_type = OPTI_TYPE_ZERO_BYTE
10058 | OPTI_TYPE_USES_BITS_64;
10059 dgst_pos0 = 0;
10060 dgst_pos1 = 1;
10061 dgst_pos2 = 2;
10062 dgst_pos3 = 3;
10063 break;
10064
10065 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10066 salt_type = SALT_TYPE_EMBEDDED;
10067 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10068 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10069 kern_type = KERN_TYPE_BSDICRYPT;
10070 dgst_size = DGST_SIZE_4_4;
10071 parse_func = bsdicrypt_parse_hash;
10072 sort_by_digest = sort_by_digest_4_4;
10073 opti_type = OPTI_TYPE_ZERO_BYTE
10074 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10075 dgst_pos0 = 0;
10076 dgst_pos1 = 1;
10077 dgst_pos2 = 2;
10078 dgst_pos3 = 3;
10079 break;
10080
10081 case 12500: hash_type = HASH_TYPE_RAR3HP;
10082 salt_type = SALT_TYPE_EMBEDDED;
10083 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10084 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10085 kern_type = KERN_TYPE_RAR3;
10086 dgst_size = DGST_SIZE_4_4;
10087 parse_func = rar3hp_parse_hash;
10088 sort_by_digest = sort_by_digest_4_4;
10089 opti_type = OPTI_TYPE_ZERO_BYTE;
10090 dgst_pos0 = 0;
10091 dgst_pos1 = 1;
10092 dgst_pos2 = 2;
10093 dgst_pos3 = 3;
10094 break;
10095
10096 case 12600: hash_type = HASH_TYPE_SHA256;
10097 salt_type = SALT_TYPE_INTERN;
10098 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10099 opts_type = OPTS_TYPE_PT_GENERATE_BE
10100 | OPTS_TYPE_PT_ADD80;
10101 kern_type = KERN_TYPE_CF10;
10102 dgst_size = DGST_SIZE_4_8;
10103 parse_func = cf10_parse_hash;
10104 sort_by_digest = sort_by_digest_4_8;
10105 opti_type = OPTI_TYPE_ZERO_BYTE
10106 | OPTI_TYPE_PRECOMPUTE_INIT
10107 | OPTI_TYPE_EARLY_SKIP
10108 | OPTI_TYPE_NOT_ITERATED;
10109 dgst_pos0 = 3;
10110 dgst_pos1 = 7;
10111 dgst_pos2 = 2;
10112 dgst_pos3 = 6;
10113 break;
10114
10115 case 12700: hash_type = HASH_TYPE_AES;
10116 salt_type = SALT_TYPE_EMBEDDED;
10117 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10118 opts_type = OPTS_TYPE_PT_GENERATE_LE
10119 | OPTS_TYPE_HASH_COPY;
10120 kern_type = KERN_TYPE_MYWALLET;
10121 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10122 parse_func = mywallet_parse_hash;
10123 sort_by_digest = sort_by_digest_4_5;
10124 opti_type = OPTI_TYPE_ZERO_BYTE;
10125 dgst_pos0 = 0;
10126 dgst_pos1 = 1;
10127 dgst_pos2 = 2;
10128 dgst_pos3 = 3;
10129 break;
10130
10131 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10132 salt_type = SALT_TYPE_EMBEDDED;
10133 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10134 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10135 kern_type = KERN_TYPE_MS_DRSR;
10136 dgst_size = DGST_SIZE_4_8;
10137 parse_func = ms_drsr_parse_hash;
10138 sort_by_digest = sort_by_digest_4_8;
10139 opti_type = OPTI_TYPE_ZERO_BYTE;
10140 dgst_pos0 = 0;
10141 dgst_pos1 = 1;
10142 dgst_pos2 = 2;
10143 dgst_pos3 = 3;
10144 break;
10145
10146 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10147 salt_type = SALT_TYPE_EMBEDDED;
10148 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10149 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10150 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10151 dgst_size = DGST_SIZE_4_8;
10152 parse_func = androidfde_samsung_parse_hash;
10153 sort_by_digest = sort_by_digest_4_8;
10154 opti_type = OPTI_TYPE_ZERO_BYTE;
10155 dgst_pos0 = 0;
10156 dgst_pos1 = 1;
10157 dgst_pos2 = 2;
10158 dgst_pos3 = 3;
10159 break;
10160
10161 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10162 salt_type = SALT_TYPE_EMBEDDED;
10163 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10164 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10165 kern_type = KERN_TYPE_RAR5;
10166 dgst_size = DGST_SIZE_4_4;
10167 parse_func = rar5_parse_hash;
10168 sort_by_digest = sort_by_digest_4_4;
10169 opti_type = OPTI_TYPE_ZERO_BYTE;
10170 dgst_pos0 = 0;
10171 dgst_pos1 = 1;
10172 dgst_pos2 = 2;
10173 dgst_pos3 = 3;
10174 break;
10175
10176 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10177 salt_type = SALT_TYPE_EMBEDDED;
10178 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10179 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10180 kern_type = KERN_TYPE_KRB5TGS;
10181 dgst_size = DGST_SIZE_4_4;
10182 parse_func = krb5tgs_parse_hash;
10183 sort_by_digest = sort_by_digest_4_4;
10184 opti_type = OPTI_TYPE_ZERO_BYTE
10185 | OPTI_TYPE_NOT_ITERATED;
10186 dgst_pos0 = 0;
10187 dgst_pos1 = 1;
10188 dgst_pos2 = 2;
10189 dgst_pos3 = 3;
10190 break;
10191
10192 default: usage_mini_print (PROGNAME); return (-1);
10193 }
10194
10195 /**
10196 * parser
10197 */
10198
10199 data.parse_func = parse_func;
10200
10201 /**
10202 * misc stuff
10203 */
10204
10205 if (hex_salt)
10206 {
10207 if (salt_type == SALT_TYPE_INTERN)
10208 {
10209 opts_type |= OPTS_TYPE_ST_HEX;
10210 }
10211 else
10212 {
10213 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10214
10215 return (-1);
10216 }
10217 }
10218
10219 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10220 | (salt_type == SALT_TYPE_EXTERN)
10221 | (salt_type == SALT_TYPE_EMBEDDED)
10222 | (salt_type == SALT_TYPE_VIRTUAL));
10223
10224 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10225
10226 data.hash_type = hash_type;
10227 data.attack_mode = attack_mode;
10228 data.attack_kern = attack_kern;
10229 data.attack_exec = attack_exec;
10230 data.kern_type = kern_type;
10231 data.opts_type = opts_type;
10232 data.dgst_size = dgst_size;
10233 data.salt_type = salt_type;
10234 data.isSalted = isSalted;
10235 data.sort_by_digest = sort_by_digest;
10236 data.dgst_pos0 = dgst_pos0;
10237 data.dgst_pos1 = dgst_pos1;
10238 data.dgst_pos2 = dgst_pos2;
10239 data.dgst_pos3 = dgst_pos3;
10240
10241 esalt_size = 0;
10242
10243 switch (hash_mode)
10244 {
10245 case 2500: esalt_size = sizeof (wpa_t); break;
10246 case 5300: esalt_size = sizeof (ikepsk_t); break;
10247 case 5400: esalt_size = sizeof (ikepsk_t); break;
10248 case 5500: esalt_size = sizeof (netntlm_t); break;
10249 case 5600: esalt_size = sizeof (netntlm_t); break;
10250 case 6211: esalt_size = sizeof (tc_t); break;
10251 case 6212: esalt_size = sizeof (tc_t); break;
10252 case 6213: esalt_size = sizeof (tc_t); break;
10253 case 6221: esalt_size = sizeof (tc_t); break;
10254 case 6222: esalt_size = sizeof (tc_t); break;
10255 case 6223: esalt_size = sizeof (tc_t); break;
10256 case 6231: esalt_size = sizeof (tc_t); break;
10257 case 6232: esalt_size = sizeof (tc_t); break;
10258 case 6233: esalt_size = sizeof (tc_t); break;
10259 case 6241: esalt_size = sizeof (tc_t); break;
10260 case 6242: esalt_size = sizeof (tc_t); break;
10261 case 6243: esalt_size = sizeof (tc_t); break;
10262 case 6600: esalt_size = sizeof (agilekey_t); break;
10263 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10264 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10265 case 7300: esalt_size = sizeof (rakp_t); break;
10266 case 7500: esalt_size = sizeof (krb5pa_t); break;
10267 case 8200: esalt_size = sizeof (cloudkey_t); break;
10268 case 8800: esalt_size = sizeof (androidfde_t); break;
10269 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10270 case 9400: esalt_size = sizeof (office2007_t); break;
10271 case 9500: esalt_size = sizeof (office2010_t); break;
10272 case 9600: esalt_size = sizeof (office2013_t); break;
10273 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10274 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10275 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10276 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10277 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10278 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10279 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10280 case 10200: esalt_size = sizeof (cram_md5_t); break;
10281 case 10400: esalt_size = sizeof (pdf_t); break;
10282 case 10410: esalt_size = sizeof (pdf_t); break;
10283 case 10420: esalt_size = sizeof (pdf_t); break;
10284 case 10500: esalt_size = sizeof (pdf_t); break;
10285 case 10600: esalt_size = sizeof (pdf_t); break;
10286 case 10700: esalt_size = sizeof (pdf_t); break;
10287 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10288 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10289 case 11400: esalt_size = sizeof (sip_t); break;
10290 case 11600: esalt_size = sizeof (seven_zip_t); break;
10291 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10292 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10293 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10294 case 13000: esalt_size = sizeof (rar5_t); break;
10295 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10296 }
10297
10298 data.esalt_size = esalt_size;
10299
10300 /**
10301 * choose dictionary parser
10302 */
10303
10304 if (hash_type == HASH_TYPE_LM)
10305 {
10306 get_next_word_func = get_next_word_lm;
10307 }
10308 else if (opts_type & OPTS_TYPE_PT_UPPER)
10309 {
10310 get_next_word_func = get_next_word_uc;
10311 }
10312 else
10313 {
10314 get_next_word_func = get_next_word_std;
10315 }
10316
10317 /**
10318 * dictstat
10319 */
10320
10321 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10322
10323 #ifdef _POSIX
10324 size_t dictstat_nmemb = 0;
10325 #endif
10326
10327 #ifdef _WIN
10328 uint dictstat_nmemb = 0;
10329 #endif
10330
10331 char dictstat[256] = { 0 };
10332
10333 FILE *dictstat_fp = NULL;
10334
10335 if (keyspace == 0)
10336 {
10337 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10338
10339 dictstat_fp = fopen (dictstat, "rb");
10340
10341 if (dictstat_fp)
10342 {
10343 #ifdef _POSIX
10344 struct stat tmpstat;
10345
10346 fstat (fileno (dictstat_fp), &tmpstat);
10347 #endif
10348
10349 #ifdef _WIN
10350 struct stat64 tmpstat;
10351
10352 _fstat64 (fileno (dictstat_fp), &tmpstat);
10353 #endif
10354
10355 if (tmpstat.st_mtime < COMPTIME)
10356 {
10357 /* with v0.15 the format changed so we have to ensure user is using a good version
10358 since there is no version-header in the dictstat file */
10359
10360 fclose (dictstat_fp);
10361
10362 unlink (dictstat);
10363 }
10364 else
10365 {
10366 while (!feof (dictstat_fp))
10367 {
10368 dictstat_t d;
10369
10370 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10371
10372 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10373
10374 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10375 {
10376 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10377
10378 return -1;
10379 }
10380 }
10381
10382 fclose (dictstat_fp);
10383 }
10384 }
10385 }
10386
10387 /**
10388 * potfile
10389 */
10390
10391 char potfile[256] = { 0 };
10392
10393 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10394
10395 data.pot_fp = NULL;
10396
10397 FILE *out_fp = NULL;
10398 FILE *pot_fp = NULL;
10399
10400 if (show == 1 || left == 1)
10401 {
10402 pot_fp = fopen (potfile, "rb");
10403
10404 if (pot_fp == NULL)
10405 {
10406 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10407
10408 return (-1);
10409 }
10410
10411 if (outfile != NULL)
10412 {
10413 if ((out_fp = fopen (outfile, "ab")) == NULL)
10414 {
10415 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10416
10417 fclose (pot_fp);
10418
10419 return (-1);
10420 }
10421 }
10422 else
10423 {
10424 out_fp = stdout;
10425 }
10426 }
10427 else
10428 {
10429 if (potfile_disable == 0)
10430 {
10431 pot_fp = fopen (potfile, "ab");
10432
10433 if (pot_fp == NULL)
10434 {
10435 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10436
10437 return (-1);
10438 }
10439
10440 data.pot_fp = pot_fp;
10441 }
10442 }
10443
10444 pot_t *pot = NULL;
10445
10446 uint pot_cnt = 0;
10447 uint pot_avail = 0;
10448
10449 if (show == 1 || left == 1)
10450 {
10451 SUPPRESS_OUTPUT = 1;
10452
10453 pot_avail = count_lines (pot_fp);
10454
10455 rewind (pot_fp);
10456
10457 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10458
10459 uint pot_hashes_avail = 0;
10460
10461 uint line_num = 0;
10462
10463 while (!feof (pot_fp))
10464 {
10465 line_num++;
10466
10467 char line_buf[BUFSIZ] = { 0 };
10468
10469 int line_len = fgetl (pot_fp, line_buf);
10470
10471 if (line_len == 0) continue;
10472
10473 char *plain_buf = line_buf + line_len;
10474
10475 pot_t *pot_ptr = &pot[pot_cnt];
10476
10477 hash_t *hashes_buf = &pot_ptr->hash;
10478
10479 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10480 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10481
10482 if (pot_cnt == pot_hashes_avail)
10483 {
10484 uint pos = 0;
10485
10486 for (pos = 0; pos < INCR_POT; pos++)
10487 {
10488 if ((pot_cnt + pos) >= pot_avail) break;
10489
10490 pot_t *tmp_pot = &pot[pot_cnt + pos];
10491
10492 hash_t *tmp_hash = &tmp_pot->hash;
10493
10494 tmp_hash->digest = mymalloc (dgst_size);
10495
10496 if (isSalted)
10497 {
10498 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10499 }
10500
10501 if (esalt_size)
10502 {
10503 tmp_hash->esalt = mymalloc (esalt_size);
10504 }
10505
10506 pot_hashes_avail++;
10507 }
10508 }
10509
10510 int plain_len = 0;
10511
10512 int parser_status;
10513
10514 int iter = MAX_CUT_TRIES;
10515
10516 do
10517 {
10518 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10519 {
10520 if (line_buf[i] == ':')
10521 {
10522 line_len--;
10523
10524 break;
10525 }
10526 }
10527
10528 if (data.hash_mode != 2500)
10529 {
10530 parser_status = parse_func (line_buf, line_len, hashes_buf);
10531 }
10532 else
10533 {
10534 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10535
10536 if (line_len > max_salt_size)
10537 {
10538 parser_status = PARSER_GLOBAL_LENGTH;
10539 }
10540 else
10541 {
10542 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10543
10544 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10545
10546 hashes_buf->salt->salt_len = line_len;
10547
10548 parser_status = PARSER_OK;
10549 }
10550 }
10551
10552 // if NOT parsed without error, we add the ":" to the plain
10553
10554 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10555 {
10556 plain_len++;
10557 plain_buf--;
10558 }
10559
10560 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10561
10562 if (parser_status < PARSER_GLOBAL_ZERO)
10563 {
10564 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10565
10566 continue;
10567 }
10568
10569 if (plain_len >= 255) continue;
10570
10571 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10572
10573 pot_ptr->plain_len = plain_len;
10574
10575 pot_cnt++;
10576 }
10577
10578 fclose (pot_fp);
10579
10580 SUPPRESS_OUTPUT = 0;
10581
10582 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10583 }
10584
10585 /**
10586 * word len
10587 */
10588
10589 uint pw_min = PW_MIN;
10590 uint pw_max = PW_MAX;
10591
10592 switch (hash_mode)
10593 {
10594 case 400: if (pw_max > 40) pw_max = 40;
10595 break;
10596 case 500: if (pw_max > 16) pw_max = 16;
10597 break;
10598 case 1500: if (pw_max > 8) pw_max = 8;
10599 break;
10600 case 1600: if (pw_max > 16) pw_max = 16;
10601 break;
10602 case 1800: if (pw_max > 16) pw_max = 16;
10603 break;
10604 case 2100: if (pw_max > 16) pw_max = 16;
10605 break;
10606 case 2500: if (pw_min < 8) pw_min = 8;
10607 break;
10608 case 3000: if (pw_max > 7) pw_max = 7;
10609 break;
10610 case 5200: if (pw_max > 24) pw_max = 24;
10611 break;
10612 case 5800: if (pw_max > 16) pw_max = 16;
10613 break;
10614 case 6300: if (pw_max > 16) pw_max = 16;
10615 break;
10616 case 7400: if (pw_max > 16) pw_max = 16;
10617 break;
10618 case 7900: if (pw_max > 48) pw_max = 48;
10619 break;
10620 case 8500: if (pw_max > 8) pw_max = 8;
10621 break;
10622 case 8600: if (pw_max > 16) pw_max = 16;
10623 break;
10624 case 9710: pw_min = 5;
10625 pw_max = 5;
10626 break;
10627 case 9810: pw_min = 5;
10628 pw_max = 5;
10629 break;
10630 case 10410: pw_min = 5;
10631 pw_max = 5;
10632 break;
10633 case 10300: if (pw_max < 3) pw_min = 3;
10634 if (pw_max > 40) pw_max = 40;
10635 break;
10636 case 10500: if (pw_max < 3) pw_min = 3;
10637 if (pw_max > 40) pw_max = 40;
10638 break;
10639 case 10700: if (pw_max > 16) pw_max = 16;
10640 break;
10641 case 11300: if (pw_max > 40) pw_max = 40;
10642 break;
10643 case 12500: if (pw_max > 20) pw_max = 20;
10644 break;
10645 case 12800: if (pw_max > 24) pw_max = 24;
10646 break;
10647 }
10648
10649 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10650 {
10651 switch (attack_kern)
10652 {
10653 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10654 break;
10655 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10656 break;
10657 }
10658 }
10659
10660 /**
10661 * charsets : keep them together for more easy maintainnce
10662 */
10663
10664 cs_t mp_sys[6] = { { { 0 }, 0 } };
10665 cs_t mp_usr[4] = { { { 0 }, 0 } };
10666
10667 mp_setup_sys (mp_sys);
10668
10669 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10670 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10671 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10672 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10673
10674 /**
10675 * load hashes, part I: find input mode, count hashes
10676 */
10677
10678 uint hashlist_mode = 0;
10679 uint hashlist_format = HLFMT_HASHCAT;
10680
10681 uint hashes_avail = 0;
10682
10683 if (benchmark == 0)
10684 {
10685 struct stat f;
10686
10687 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10688
10689 if ((hash_mode == 2500) ||
10690 (hash_mode == 5200) ||
10691 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10692 (hash_mode == 9000))
10693 {
10694 hashlist_mode = HL_MODE_ARG;
10695
10696 char *hashfile = myargv[optind];
10697
10698 data.hashfile = hashfile;
10699
10700 logfile_top_var_string ("target", hashfile);
10701 }
10702
10703 if (hashlist_mode == HL_MODE_ARG)
10704 {
10705 if (hash_mode == 2500)
10706 {
10707 struct stat st;
10708
10709 if (stat (data.hashfile, &st) == -1)
10710 {
10711 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10712
10713 return (-1);
10714 }
10715
10716 hashes_avail = st.st_size / sizeof (hccap_t);
10717 }
10718 else
10719 {
10720 hashes_avail = 1;
10721 }
10722 }
10723 else if (hashlist_mode == HL_MODE_FILE)
10724 {
10725 char *hashfile = myargv[optind];
10726
10727 data.hashfile = hashfile;
10728
10729 logfile_top_var_string ("target", hashfile);
10730
10731 FILE *fp = NULL;
10732
10733 if ((fp = fopen (hashfile, "rb")) == NULL)
10734 {
10735 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10736
10737 return (-1);
10738 }
10739
10740 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10741
10742 hashes_avail = count_lines (fp);
10743
10744 rewind (fp);
10745
10746 if (hashes_avail == 0)
10747 {
10748 log_error ("ERROR: hashfile is empty or corrupt");
10749
10750 fclose (fp);
10751
10752 return (-1);
10753 }
10754
10755 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10756
10757 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10758 {
10759 log_error ("ERROR: remove not supported in native hashfile-format mode");
10760
10761 fclose (fp);
10762
10763 return (-1);
10764 }
10765
10766 fclose (fp);
10767 }
10768 }
10769 else
10770 {
10771 hashlist_mode = HL_MODE_ARG;
10772
10773 hashes_avail = 1;
10774 }
10775
10776 if (hash_mode == 3000) hashes_avail *= 2;
10777
10778 data.hashlist_mode = hashlist_mode;
10779 data.hashlist_format = hashlist_format;
10780
10781 logfile_top_uint (hashlist_mode);
10782 logfile_top_uint (hashlist_format);
10783
10784 /**
10785 * load hashes, part II: allocate required memory, set pointers
10786 */
10787
10788 hash_t *hashes_buf = NULL;
10789 void *digests_buf = NULL;
10790 salt_t *salts_buf = NULL;
10791 void *esalts_buf = NULL;
10792
10793 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10794
10795 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10796
10797 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10798 {
10799 u32 hash_pos;
10800
10801 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10802 {
10803 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10804
10805 hashes_buf[hash_pos].hash_info = hash_info;
10806
10807 if (username && (remove || show || left))
10808 {
10809 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10810 }
10811
10812 if (benchmark)
10813 {
10814 hash_info->orighash = (char *) mymalloc (256);
10815 }
10816 }
10817 }
10818
10819 if (isSalted)
10820 {
10821 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10822
10823 if (esalt_size)
10824 {
10825 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10826 }
10827 }
10828 else
10829 {
10830 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10831 }
10832
10833 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10834 {
10835 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10836
10837 if (isSalted)
10838 {
10839 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10840
10841 if (esalt_size)
10842 {
10843 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10844 }
10845 }
10846 else
10847 {
10848 hashes_buf[hash_pos].salt = &salts_buf[0];
10849 }
10850 }
10851
10852 /**
10853 * load hashes, part III: parse hashes or generate them if benchmark
10854 */
10855
10856 uint hashes_cnt = 0;
10857
10858 if (benchmark == 0)
10859 {
10860 if (keyspace == 1)
10861 {
10862 // useless to read hash file for keyspace, cheat a little bit w/ optind
10863 }
10864 else if (hashes_avail == 0)
10865 {
10866 }
10867 else if (hashlist_mode == HL_MODE_ARG)
10868 {
10869 char *input_buf = myargv[optind];
10870
10871 uint input_len = strlen (input_buf);
10872
10873 logfile_top_var_string ("target", input_buf);
10874
10875 char *hash_buf = NULL;
10876 int hash_len = 0;
10877
10878 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10879
10880 if (hash_len)
10881 {
10882 if (opts_type & OPTS_TYPE_HASH_COPY)
10883 {
10884 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10885
10886 hash_info_tmp->orighash = mystrdup (hash_buf);
10887 }
10888
10889 if (isSalted)
10890 {
10891 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10892 }
10893
10894 int parser_status = PARSER_OK;
10895
10896 if (hash_mode == 2500)
10897 {
10898 if (hash_len == 0)
10899 {
10900 log_error ("ERROR: hccap file not specified");
10901
10902 return (-1);
10903 }
10904
10905 hashlist_mode = HL_MODE_FILE;
10906
10907 data.hashlist_mode = hashlist_mode;
10908
10909 FILE *fp = fopen (hash_buf, "rb");
10910
10911 if (fp == NULL)
10912 {
10913 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10914
10915 return (-1);
10916 }
10917
10918 if (hashes_avail < 1)
10919 {
10920 log_error ("ERROR: hccap file is empty or corrupt");
10921
10922 fclose (fp);
10923
10924 return (-1);
10925 }
10926
10927 uint hccap_size = sizeof (hccap_t);
10928
10929 char *in = (char *) mymalloc (hccap_size);
10930
10931 while (!feof (fp))
10932 {
10933 int n = fread (in, hccap_size, 1, fp);
10934
10935 if (n != 1)
10936 {
10937 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10938
10939 break;
10940 }
10941
10942 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10943
10944 if (parser_status != PARSER_OK)
10945 {
10946 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10947
10948 continue;
10949 }
10950
10951 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10952
10953 if ((show == 1) || (left == 1))
10954 {
10955 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10956
10957 char *salt_ptr = (char *) tmp_salt->salt_buf;
10958
10959 int cur_pos = tmp_salt->salt_len;
10960 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10961
10962 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10963
10964 u8 *pke_ptr = (u8 *) wpa->pke;
10965
10966 // do the appending task
10967
10968 snprintf (salt_ptr + cur_pos,
10969 rem_len,
10970 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10971 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10972 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10973
10974
10975 // memset () the remaining part of the salt
10976
10977 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10978 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10979
10980 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10981
10982 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10983 }
10984
10985 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);
10986 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);
10987
10988 hashes_cnt++;
10989 }
10990
10991 fclose (fp);
10992
10993 myfree (in);
10994 }
10995 else if (hash_mode == 3000)
10996 {
10997 if (hash_len == 32)
10998 {
10999 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11000
11001 hash_t *lm_hash_left = NULL;
11002
11003 if (parser_status == PARSER_OK)
11004 {
11005 lm_hash_left = &hashes_buf[hashes_cnt];
11006
11007 hashes_cnt++;
11008 }
11009 else
11010 {
11011 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11012 }
11013
11014 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11015
11016 hash_t *lm_hash_right = NULL;
11017
11018 if (parser_status == PARSER_OK)
11019 {
11020 lm_hash_right = &hashes_buf[hashes_cnt];
11021
11022 hashes_cnt++;
11023 }
11024 else
11025 {
11026 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11027 }
11028
11029 // show / left
11030
11031 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11032 {
11033 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);
11034 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);
11035 }
11036 }
11037 else
11038 {
11039 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11040
11041 if (parser_status == PARSER_OK)
11042 {
11043 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11044 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11045 }
11046
11047 if (parser_status == PARSER_OK)
11048 {
11049 hashes_cnt++;
11050 }
11051 else
11052 {
11053 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11054 }
11055 }
11056 }
11057 else
11058 {
11059 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11060
11061 if (parser_status == PARSER_OK)
11062 {
11063 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11064 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11065 }
11066
11067 if (parser_status == PARSER_OK)
11068 {
11069 hashes_cnt++;
11070 }
11071 else
11072 {
11073 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11074 }
11075 }
11076 }
11077 }
11078 else if (hashlist_mode == HL_MODE_FILE)
11079 {
11080 char *hashfile = data.hashfile;
11081
11082 FILE *fp;
11083
11084 if ((fp = fopen (hashfile, "rb")) == NULL)
11085 {
11086 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11087
11088 return (-1);
11089 }
11090
11091 uint line_num = 0;
11092
11093 while (!feof (fp))
11094 {
11095 line_num++;
11096
11097 char line_buf[BUFSIZ] = { 0 };
11098
11099 int line_len = fgetl (fp, line_buf);
11100
11101 if (line_len == 0) continue;
11102
11103 char *hash_buf = NULL;
11104 int hash_len = 0;
11105
11106 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11107
11108 if (username)
11109 {
11110 char *user_buf = NULL;
11111 int user_len = 0;
11112
11113 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11114
11115 if (remove || show)
11116 {
11117 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11118
11119 *user = (user_t *) mymalloc (sizeof (user_t));
11120
11121 user_t *user_ptr = *user;
11122
11123 if (user_buf != NULL)
11124 {
11125 user_ptr->user_name = mystrdup (user_buf);
11126 }
11127 else
11128 {
11129 user_ptr->user_name = mystrdup ("");
11130 }
11131
11132 user_ptr->user_len = user_len;
11133 }
11134 }
11135
11136 if (opts_type & OPTS_TYPE_HASH_COPY)
11137 {
11138 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11139
11140 hash_info_tmp->orighash = mystrdup (hash_buf);
11141 }
11142
11143 if (isSalted)
11144 {
11145 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11146 }
11147
11148 if (hash_mode == 3000)
11149 {
11150 if (hash_len == 32)
11151 {
11152 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11153
11154 if (parser_status < PARSER_GLOBAL_ZERO)
11155 {
11156 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11157
11158 continue;
11159 }
11160
11161 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11162
11163 hashes_cnt++;
11164
11165 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11166
11167 if (parser_status < PARSER_GLOBAL_ZERO)
11168 {
11169 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11170
11171 continue;
11172 }
11173
11174 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11175
11176 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);
11177
11178 hashes_cnt++;
11179
11180 // show / left
11181
11182 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);
11183 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);
11184 }
11185 else
11186 {
11187 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11188
11189 if (parser_status < PARSER_GLOBAL_ZERO)
11190 {
11191 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11192
11193 continue;
11194 }
11195
11196 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);
11197
11198 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11199 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11200
11201 hashes_cnt++;
11202 }
11203 }
11204 else
11205 {
11206 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11207
11208 if (parser_status < PARSER_GLOBAL_ZERO)
11209 {
11210 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11211
11212 continue;
11213 }
11214
11215 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);
11216
11217 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11218 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11219
11220 hashes_cnt++;
11221 }
11222 }
11223
11224 fclose (fp);
11225
11226 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11227
11228 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11229 }
11230 }
11231 else
11232 {
11233 if (isSalted)
11234 {
11235 hashes_buf[0].salt->salt_len = 8;
11236
11237 // special salt handling
11238
11239 switch (hash_mode)
11240 {
11241 case 1500: hashes_buf[0].salt->salt_len = 2;
11242 break;
11243 case 1731: hashes_buf[0].salt->salt_len = 4;
11244 break;
11245 case 2410: hashes_buf[0].salt->salt_len = 4;
11246 break;
11247 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11248 break;
11249 case 3100: hashes_buf[0].salt->salt_len = 1;
11250 break;
11251 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11252 break;
11253 case 5800: hashes_buf[0].salt->salt_len = 16;
11254 break;
11255 case 6800: hashes_buf[0].salt->salt_len = 32;
11256 break;
11257 case 8400: hashes_buf[0].salt->salt_len = 40;
11258 break;
11259 case 8800: hashes_buf[0].salt->salt_len = 16;
11260 break;
11261 case 8900: hashes_buf[0].salt->salt_len = 16;
11262 hashes_buf[0].salt->scrypt_N = 1024;
11263 hashes_buf[0].salt->scrypt_r = 1;
11264 hashes_buf[0].salt->scrypt_p = 1;
11265 break;
11266 case 9100: hashes_buf[0].salt->salt_len = 16;
11267 break;
11268 case 9300: hashes_buf[0].salt->salt_len = 14;
11269 hashes_buf[0].salt->scrypt_N = 16384;
11270 hashes_buf[0].salt->scrypt_r = 1;
11271 hashes_buf[0].salt->scrypt_p = 1;
11272 break;
11273 case 9400: hashes_buf[0].salt->salt_len = 16;
11274 break;
11275 case 9500: hashes_buf[0].salt->salt_len = 16;
11276 break;
11277 case 9600: hashes_buf[0].salt->salt_len = 16;
11278 break;
11279 case 9700: hashes_buf[0].salt->salt_len = 16;
11280 break;
11281 case 9710: hashes_buf[0].salt->salt_len = 16;
11282 break;
11283 case 9720: hashes_buf[0].salt->salt_len = 16;
11284 break;
11285 case 9800: hashes_buf[0].salt->salt_len = 16;
11286 break;
11287 case 9810: hashes_buf[0].salt->salt_len = 16;
11288 break;
11289 case 9820: hashes_buf[0].salt->salt_len = 16;
11290 break;
11291 case 10300: hashes_buf[0].salt->salt_len = 12;
11292 break;
11293 case 11500: hashes_buf[0].salt->salt_len = 4;
11294 break;
11295 case 11600: hashes_buf[0].salt->salt_len = 4;
11296 break;
11297 case 12400: hashes_buf[0].salt->salt_len = 4;
11298 break;
11299 case 12500: hashes_buf[0].salt->salt_len = 8;
11300 break;
11301 case 12600: hashes_buf[0].salt->salt_len = 64;
11302 break;
11303 }
11304
11305 // special esalt handling
11306
11307 switch (hash_mode)
11308 {
11309 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11310 break;
11311 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11312 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11313 break;
11314 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11315 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11316 break;
11317 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11318 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11319 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11320 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11321 break;
11322 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11323 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11324 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11325 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11326 break;
11327 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11328 break;
11329 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11330 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11331 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11332 break;
11333 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11334 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11335 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11336 break;
11337 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11338 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11339 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11340 break;
11341 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11342 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11343 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11344 break;
11345 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11346 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11347 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11348 break;
11349 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11350 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11351 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11352 break;
11353 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11354 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11355 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11356 break;
11357 }
11358 }
11359
11360 // set hashfile
11361
11362 switch (hash_mode)
11363 {
11364 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11365 break;
11366 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11367 break;
11368 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11369 break;
11370 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11371 break;
11372 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11373 break;
11374 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11375 break;
11376 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11377 break;
11378 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11379 break;
11380 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11381 break;
11382 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11383 break;
11384 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11385 break;
11386 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11387 break;
11388 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11389 break;
11390 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11391 break;
11392 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11393 break;
11394 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11395 break;
11396 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11397 break;
11398 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11399 break;
11400 }
11401
11402 // set default iterations
11403
11404 switch (hash_mode)
11405 {
11406 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11407 break;
11408 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11409 break;
11410 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11411 break;
11412 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11413 break;
11414 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11415 break;
11416 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11417 break;
11418 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11419 break;
11420 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11421 break;
11422 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11423 break;
11424 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11425 break;
11426 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11427 break;
11428 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11429 break;
11430 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11431 break;
11432 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11433 break;
11434 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11435 break;
11436 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11437 break;
11438 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11439 break;
11440 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11441 break;
11442 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11443 break;
11444 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11445 break;
11446 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11447 break;
11448 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11449 break;
11450 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11451 break;
11452 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11453 break;
11454 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11455 break;
11456 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11457 break;
11458 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11459 break;
11460 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11461 break;
11462 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11463 break;
11464 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11465 break;
11466 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11467 break;
11468 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11469 break;
11470 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11471 break;
11472 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11473 break;
11474 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11475 break;
11476 case 8900: hashes_buf[0].salt->salt_iter = 1;
11477 break;
11478 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11479 break;
11480 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11481 break;
11482 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11483 break;
11484 case 9300: hashes_buf[0].salt->salt_iter = 1;
11485 break;
11486 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11487 break;
11488 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11489 break;
11490 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11491 break;
11492 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11493 break;
11494 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11495 break;
11496 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11497 break;
11498 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11499 break;
11500 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11501 break;
11502 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11503 break;
11504 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11505 break;
11506 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11507 break;
11508 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11509 break;
11510 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11511 break;
11512 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11513 break;
11514 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11515 break;
11516 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11517 break;
11518 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11519 break;
11520 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11521 break;
11522 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11523 break;
11524 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11525 break;
11526 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11527 break;
11528 }
11529
11530 hashes_cnt = 1;
11531 }
11532
11533 if (show == 1 || left == 1)
11534 {
11535 for (uint i = 0; i < pot_cnt; i++)
11536 {
11537 pot_t *pot_ptr = &pot[i];
11538
11539 hash_t *hashes_buf = &pot_ptr->hash;
11540
11541 local_free (hashes_buf->digest);
11542
11543 if (isSalted)
11544 {
11545 local_free (hashes_buf->salt);
11546 }
11547 }
11548
11549 local_free (pot);
11550
11551 if (data.quiet == 0) log_info_nn ("");
11552
11553 return (0);
11554 }
11555
11556 if (keyspace == 0)
11557 {
11558 if (hashes_cnt == 0)
11559 {
11560 log_error ("ERROR: No hashes loaded");
11561
11562 return (-1);
11563 }
11564 }
11565
11566 /**
11567 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11568 */
11569
11570 if (data.outfile != NULL)
11571 {
11572 if (data.hashfile != NULL)
11573 {
11574 #ifdef _POSIX
11575 struct stat tmpstat_outfile;
11576 struct stat tmpstat_hashfile;
11577 #endif
11578
11579 #ifdef _WIN
11580 struct stat64 tmpstat_outfile;
11581 struct stat64 tmpstat_hashfile;
11582 #endif
11583
11584 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11585
11586 if (tmp_outfile_fp)
11587 {
11588 #ifdef _POSIX
11589 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11590 #endif
11591
11592 #ifdef _WIN
11593 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11594 #endif
11595
11596 fclose (tmp_outfile_fp);
11597 }
11598
11599 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11600
11601 if (tmp_hashfile_fp)
11602 {
11603 #ifdef _POSIX
11604 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11605 #endif
11606
11607 #ifdef _WIN
11608 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11609 #endif
11610
11611 fclose (tmp_hashfile_fp);
11612 }
11613
11614 if (tmp_outfile_fp && tmp_outfile_fp)
11615 {
11616 tmpstat_outfile.st_mode = 0;
11617 tmpstat_outfile.st_nlink = 0;
11618 tmpstat_outfile.st_uid = 0;
11619 tmpstat_outfile.st_gid = 0;
11620 tmpstat_outfile.st_rdev = 0;
11621 tmpstat_outfile.st_atime = 0;
11622
11623 tmpstat_hashfile.st_mode = 0;
11624 tmpstat_hashfile.st_nlink = 0;
11625 tmpstat_hashfile.st_uid = 0;
11626 tmpstat_hashfile.st_gid = 0;
11627 tmpstat_hashfile.st_rdev = 0;
11628 tmpstat_hashfile.st_atime = 0;
11629
11630 #ifdef _POSIX
11631 tmpstat_outfile.st_blksize = 0;
11632 tmpstat_outfile.st_blocks = 0;
11633
11634 tmpstat_hashfile.st_blksize = 0;
11635 tmpstat_hashfile.st_blocks = 0;
11636 #endif
11637
11638 #ifdef _POSIX
11639 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11640 {
11641 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11642
11643 return (-1);
11644 }
11645 #endif
11646
11647 #ifdef _WIN
11648 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11649 {
11650 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11651
11652 return (-1);
11653 }
11654 #endif
11655 }
11656 }
11657 }
11658
11659 /**
11660 * Remove duplicates
11661 */
11662
11663 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11664
11665 if (isSalted)
11666 {
11667 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11668 }
11669 else
11670 {
11671 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11672 }
11673
11674 uint hashes_cnt_orig = hashes_cnt;
11675
11676 hashes_cnt = 1;
11677
11678 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11679 {
11680 if (isSalted)
11681 {
11682 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11683 {
11684 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11685 }
11686 }
11687 else
11688 {
11689 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11690 }
11691
11692 if (hashes_pos > hashes_cnt)
11693 {
11694 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11695 }
11696
11697 hashes_cnt++;
11698 }
11699
11700 /**
11701 * Potfile removes
11702 */
11703
11704 uint potfile_remove_cracks = 0;
11705
11706 if (potfile_disable == 0)
11707 {
11708 hash_t hash_buf;
11709
11710 hash_buf.digest = mymalloc (dgst_size);
11711 hash_buf.salt = NULL;
11712 hash_buf.esalt = NULL;
11713 hash_buf.hash_info = NULL;
11714 hash_buf.cracked = 0;
11715
11716 if (isSalted)
11717 {
11718 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11719 }
11720
11721 if (esalt_size)
11722 {
11723 hash_buf.esalt = mymalloc (esalt_size);
11724 }
11725
11726 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11727
11728 // no solution for these special hash types (for instane because they use hashfile in output etc)
11729 if ((hash_mode != 5200) &&
11730 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11731 (hash_mode != 9000))
11732 {
11733 FILE *fp = fopen (potfile, "rb");
11734
11735 if (fp != NULL)
11736 {
11737 while (!feof (fp))
11738 {
11739 char line_buf[BUFSIZ] = { 0 };
11740
11741 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11742
11743 if (ptr == NULL) break;
11744
11745 int line_len = strlen (line_buf);
11746
11747 if (line_len == 0) continue;
11748
11749 int iter = MAX_CUT_TRIES;
11750
11751 for (int i = line_len - 1; i && iter; i--, line_len--)
11752 {
11753 if (line_buf[i] != ':') continue;
11754
11755 if (isSalted)
11756 {
11757 memset (hash_buf.salt, 0, sizeof (salt_t));
11758 }
11759
11760 hash_t *found = NULL;
11761
11762 if (hash_mode == 6800)
11763 {
11764 if (i < 64) // 64 = 16 * uint in salt_buf[]
11765 {
11766 // manipulate salt_buf
11767 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11768
11769 hash_buf.salt->salt_len = i;
11770
11771 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11772 }
11773 }
11774 else if (hash_mode == 2500)
11775 {
11776 if (i < 64) // 64 = 16 * uint in salt_buf[]
11777 {
11778 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11779 // manipulate salt_buf
11780
11781 // to be safe work with a copy (because of line_len loop, i etc)
11782
11783 char line_buf_cpy[BUFSIZ] = { 0 };
11784
11785 memcpy (line_buf_cpy, line_buf, i);
11786
11787 char *mac2_pos = strrchr (line_buf_cpy, ':');
11788
11789 if (mac2_pos == NULL) continue;
11790
11791 mac2_pos[0] = 0;
11792 mac2_pos++;
11793
11794 if (strlen (mac2_pos) != 12) continue;
11795
11796 char *mac1_pos = strrchr (line_buf_cpy, ':');
11797
11798 if (mac1_pos == NULL) continue;
11799
11800 mac1_pos[0] = 0;
11801 mac1_pos++;
11802
11803 if (strlen (mac1_pos) != 12) continue;
11804
11805 uint essid_length = mac1_pos - line_buf_cpy - 1;
11806
11807 // here we need the ESSID
11808 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11809
11810 hash_buf.salt->salt_len = essid_length;
11811
11812 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11813
11814 if (found)
11815 {
11816 wpa_t *wpa = (wpa_t *) found->esalt;
11817
11818 uint pke[25] = { 0 };
11819
11820 char *pke_ptr = (char *) pke;
11821
11822 for (uint i = 0; i < 25; i++)
11823 {
11824 pke[i] = byte_swap_32 (wpa->pke[i]);
11825 }
11826
11827 u8 mac1[6] = { 0 };
11828 u8 mac2[6] = { 0 };
11829
11830 memcpy (mac1, pke_ptr + 23, 6);
11831 memcpy (mac2, pke_ptr + 29, 6);
11832
11833 // compare hex string(s) vs binary MAC address(es)
11834
11835 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11836 {
11837 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11838 {
11839 found = NULL;
11840 break;
11841 }
11842 }
11843
11844 // early skip ;)
11845 if (!found) continue;
11846
11847 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11848 {
11849 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11850 {
11851 found = NULL;
11852 break;
11853 }
11854 }
11855 }
11856 }
11857 }
11858 else
11859 {
11860 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11861
11862 if (parser_status == PARSER_OK)
11863 {
11864 if (isSalted)
11865 {
11866 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11867 }
11868 else
11869 {
11870 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11871 }
11872 }
11873 }
11874
11875 if (found == NULL) continue;
11876
11877 if (!found->cracked) potfile_remove_cracks++;
11878
11879 found->cracked = 1;
11880
11881 if (found) break;
11882
11883 iter--;
11884 }
11885 }
11886
11887 fclose (fp);
11888 }
11889 }
11890
11891 if (esalt_size)
11892 {
11893 local_free (hash_buf.esalt);
11894 }
11895
11896 if (isSalted)
11897 {
11898 local_free (hash_buf.salt);
11899 }
11900
11901 local_free (hash_buf.digest);
11902 }
11903
11904 /**
11905 * Now generate all the buffers required for later
11906 */
11907
11908 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11909
11910 salt_t *salts_buf_new = NULL;
11911 void *esalts_buf_new = NULL;
11912
11913 if (isSalted)
11914 {
11915 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11916
11917 if (esalt_size)
11918 {
11919 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11920 }
11921 }
11922 else
11923 {
11924 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11925 }
11926
11927 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11928
11929 uint digests_cnt = hashes_cnt;
11930 uint digests_done = 0;
11931
11932 uint size_digests = digests_cnt * dgst_size;
11933 uint size_shown = digests_cnt * sizeof (uint);
11934
11935 uint *digests_shown = (uint *) mymalloc (size_shown);
11936 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11937
11938 uint salts_cnt = 0;
11939 uint salts_done = 0;
11940
11941 hashinfo_t **hash_info = NULL;
11942
11943 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11944 {
11945 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11946
11947 if (username && (remove || show))
11948 {
11949 uint user_pos;
11950
11951 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11952 {
11953 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11954
11955 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11956 }
11957 }
11958 }
11959
11960 uint *salts_shown = (uint *) mymalloc (size_shown);
11961
11962 salt_t *salt_buf;
11963
11964 {
11965 // copied from inner loop
11966
11967 salt_buf = &salts_buf_new[salts_cnt];
11968
11969 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11970
11971 if (esalt_size)
11972 {
11973 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11974 }
11975
11976 salt_buf->digests_cnt = 0;
11977 salt_buf->digests_done = 0;
11978 salt_buf->digests_offset = 0;
11979
11980 salts_cnt++;
11981 }
11982
11983 if (hashes_buf[0].cracked == 1)
11984 {
11985 digests_shown[0] = 1;
11986
11987 digests_done++;
11988
11989 salt_buf->digests_done++;
11990 }
11991
11992 salt_buf->digests_cnt++;
11993
11994 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11995
11996 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11997 {
11998 hash_info[0] = hashes_buf[0].hash_info;
11999 }
12000
12001 // copy from inner loop
12002
12003 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12004 {
12005 if (isSalted)
12006 {
12007 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12008 {
12009 salt_buf = &salts_buf_new[salts_cnt];
12010
12011 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12012
12013 if (esalt_size)
12014 {
12015 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12016 }
12017
12018 salt_buf->digests_cnt = 0;
12019 salt_buf->digests_done = 0;
12020 salt_buf->digests_offset = hashes_pos;
12021
12022 salts_cnt++;
12023 }
12024 }
12025
12026 if (hashes_buf[hashes_pos].cracked == 1)
12027 {
12028 digests_shown[hashes_pos] = 1;
12029
12030 digests_done++;
12031
12032 salt_buf->digests_done++;
12033 }
12034
12035 salt_buf->digests_cnt++;
12036
12037 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12038
12039 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12040 {
12041 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12042 }
12043 }
12044
12045 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12046 {
12047 salt_t *salt_buf = &salts_buf_new[salt_pos];
12048
12049 if (salt_buf->digests_done == salt_buf->digests_cnt)
12050 {
12051 salts_shown[salt_pos] = 1;
12052
12053 salts_done++;
12054 }
12055
12056 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12057 }
12058
12059 local_free (digests_buf);
12060 local_free (salts_buf);
12061 local_free (esalts_buf);
12062
12063 digests_buf = digests_buf_new;
12064 salts_buf = salts_buf_new;
12065 esalts_buf = esalts_buf_new;
12066
12067 local_free (hashes_buf);
12068
12069 /**
12070 * special modification not set from parser
12071 */
12072
12073 switch (hash_mode)
12074 {
12075 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12076 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12077 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12078 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12079 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12080 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12081 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12082 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12083 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12084 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12085 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12086 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12087 }
12088
12089 if (truecrypt_keyfiles)
12090 {
12091 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12092
12093 char *keyfiles = strdup (truecrypt_keyfiles);
12094
12095 char *keyfile = strtok (keyfiles, ",");
12096
12097 do
12098 {
12099 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12100
12101 } while ((keyfile = strtok (NULL, ",")) != NULL);
12102
12103 free (keyfiles);
12104 }
12105
12106 data.digests_cnt = digests_cnt;
12107 data.digests_done = digests_done;
12108 data.digests_buf = digests_buf;
12109 data.digests_shown = digests_shown;
12110 data.digests_shown_tmp = digests_shown_tmp;
12111
12112 data.salts_cnt = salts_cnt;
12113 data.salts_done = salts_done;
12114 data.salts_buf = salts_buf;
12115 data.salts_shown = salts_shown;
12116
12117 data.esalts_buf = esalts_buf;
12118 data.hash_info = hash_info;
12119
12120 /**
12121 * Automatic Optimizers
12122 */
12123
12124 if (salts_cnt == 1)
12125 opti_type |= OPTI_TYPE_SINGLE_SALT;
12126
12127 if (digests_cnt == 1)
12128 opti_type |= OPTI_TYPE_SINGLE_HASH;
12129
12130 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12131 opti_type |= OPTI_TYPE_NOT_ITERATED;
12132
12133 if (attack_mode == ATTACK_MODE_BF)
12134 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12135
12136 data.opti_type = opti_type;
12137
12138 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12139 {
12140 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12141 {
12142 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12143 {
12144 if (opts_type & OPTS_TYPE_ST_ADD80)
12145 {
12146 opts_type &= ~OPTS_TYPE_ST_ADD80;
12147 opts_type |= OPTS_TYPE_PT_ADD80;
12148 }
12149
12150 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12151 {
12152 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12153 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12154 }
12155
12156 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12157 {
12158 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12159 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12160 }
12161 }
12162 }
12163 }
12164
12165 /**
12166 * Some algorithm, like descrypt, can benefit from JIT compilation
12167 */
12168
12169 int force_jit_compilation = -1;
12170
12171 if (hash_mode == 8900)
12172 {
12173 force_jit_compilation = 8900;
12174 }
12175 else if (hash_mode == 9300)
12176 {
12177 force_jit_compilation = 8900;
12178 }
12179 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12180 {
12181 force_jit_compilation = 1500;
12182 }
12183
12184 /**
12185 * generate bitmap tables
12186 */
12187
12188 const uint bitmap_shift1 = 5;
12189 const uint bitmap_shift2 = 13;
12190
12191 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12192
12193 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12194 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12195 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12196 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12197 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12198 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12199 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12200 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12201
12202 uint bitmap_bits;
12203 uint bitmap_nums;
12204 uint bitmap_mask;
12205 uint bitmap_size;
12206
12207 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12208 {
12209 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12210
12211 bitmap_nums = 1 << bitmap_bits;
12212
12213 bitmap_mask = bitmap_nums - 1;
12214
12215 bitmap_size = bitmap_nums * sizeof (uint);
12216
12217 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12218
12219 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;
12220 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;
12221
12222 break;
12223 }
12224
12225 bitmap_nums = 1 << bitmap_bits;
12226
12227 bitmap_mask = bitmap_nums - 1;
12228
12229 bitmap_size = bitmap_nums * sizeof (uint);
12230
12231 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);
12232 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);
12233
12234 /**
12235 * prepare quick rule
12236 */
12237
12238 data.rule_buf_l = rule_buf_l;
12239 data.rule_buf_r = rule_buf_r;
12240
12241 int rule_len_l = (int) strlen (rule_buf_l);
12242 int rule_len_r = (int) strlen (rule_buf_r);
12243
12244 data.rule_len_l = rule_len_l;
12245 data.rule_len_r = rule_len_r;
12246
12247 /**
12248 * load rules
12249 */
12250
12251 uint *all_kernel_rules_cnt = NULL;
12252
12253 kernel_rule_t **all_kernel_rules_buf = NULL;
12254
12255 if (rp_files_cnt)
12256 {
12257 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12258
12259 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12260 }
12261
12262 char rule_buf[BUFSIZ] = { 0 };
12263
12264 int rule_len = 0;
12265
12266 for (uint i = 0; i < rp_files_cnt; i++)
12267 {
12268 uint kernel_rules_avail = 0;
12269
12270 uint kernel_rules_cnt = 0;
12271
12272 kernel_rule_t *kernel_rules_buf = NULL;
12273
12274 char *rp_file = rp_files[i];
12275
12276 char in[BLOCK_SIZE] = { 0 };
12277 char out[BLOCK_SIZE] = { 0 };
12278
12279 FILE *fp = NULL;
12280
12281 uint rule_line = 0;
12282
12283 if ((fp = fopen (rp_file, "rb")) == NULL)
12284 {
12285 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12286
12287 return (-1);
12288 }
12289
12290 while (!feof (fp))
12291 {
12292 memset (rule_buf, 0, BUFSIZ);
12293
12294 rule_len = fgetl (fp, rule_buf);
12295
12296 rule_line++;
12297
12298 if (rule_len == 0) continue;
12299
12300 if (rule_buf[0] == '#') continue;
12301
12302 if (kernel_rules_avail == kernel_rules_cnt)
12303 {
12304 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12305
12306 kernel_rules_avail += INCR_RULES;
12307 }
12308
12309 memset (in, 0, BLOCK_SIZE);
12310 memset (out, 0, BLOCK_SIZE);
12311
12312 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12313
12314 if (result == -1)
12315 {
12316 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12317
12318 continue;
12319 }
12320
12321 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12322 {
12323 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12324
12325 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12326
12327 continue;
12328 }
12329
12330 /* its so slow
12331 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12332 {
12333 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12334
12335 continue;
12336 }
12337 */
12338
12339 kernel_rules_cnt++;
12340 }
12341
12342 fclose (fp);
12343
12344 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12345
12346 all_kernel_rules_buf[i] = kernel_rules_buf;
12347 }
12348
12349 /**
12350 * merge rules or automatic rule generator
12351 */
12352
12353 uint kernel_rules_cnt = 0;
12354
12355 kernel_rule_t *kernel_rules_buf = NULL;
12356
12357 if (attack_mode == ATTACK_MODE_STRAIGHT)
12358 {
12359 if (rp_files_cnt)
12360 {
12361 kernel_rules_cnt = 1;
12362
12363 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12364
12365 repeats[0] = kernel_rules_cnt;
12366
12367 for (uint i = 0; i < rp_files_cnt; i++)
12368 {
12369 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12370
12371 repeats[i + 1] = kernel_rules_cnt;
12372 }
12373
12374 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12375
12376 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12377
12378 for (uint i = 0; i < kernel_rules_cnt; i++)
12379 {
12380 uint out_pos = 0;
12381
12382 kernel_rule_t *out = &kernel_rules_buf[i];
12383
12384 for (uint j = 0; j < rp_files_cnt; j++)
12385 {
12386 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12387 uint in_pos;
12388
12389 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12390
12391 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12392 {
12393 if (out_pos == RULES_MAX - 1)
12394 {
12395 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12396
12397 break;
12398 }
12399
12400 out->cmds[out_pos] = in->cmds[in_pos];
12401 }
12402 }
12403 }
12404
12405 local_free (repeats);
12406 }
12407 else if (rp_gen)
12408 {
12409 uint kernel_rules_avail = 0;
12410
12411 while (kernel_rules_cnt < rp_gen)
12412 {
12413 if (kernel_rules_avail == kernel_rules_cnt)
12414 {
12415 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12416
12417 kernel_rules_avail += INCR_RULES;
12418 }
12419
12420 memset (rule_buf, 0, BLOCK_SIZE);
12421
12422 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12423
12424 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12425
12426 kernel_rules_cnt++;
12427 }
12428 }
12429 }
12430
12431 /**
12432 * generate NOP rules
12433 */
12434
12435 if (kernel_rules_cnt == 0)
12436 {
12437 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12438
12439 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12440
12441 kernel_rules_cnt++;
12442 }
12443
12444 data.kernel_rules_cnt = kernel_rules_cnt;
12445 data.kernel_rules_buf = kernel_rules_buf;
12446
12447 /**
12448 * OpenCL platforms: detect
12449 */
12450
12451 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12452 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12453
12454 cl_uint platforms_cnt = 0;
12455 cl_uint platform_devices_cnt = 0;
12456
12457 if (keyspace == 0)
12458 {
12459 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12460
12461 if (platforms_cnt == 0)
12462 {
12463 log_error ("ERROR: No OpenCL compatible platform found");
12464
12465 return (-1);
12466 }
12467 }
12468
12469 /**
12470 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12471 */
12472
12473 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12474 {
12475 cl_platform_id platform = platforms[platform_id];
12476
12477 char platform_vendor[INFOSZ] = { 0 };
12478
12479 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12480
12481 #ifdef HAVE_HWMON
12482 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12483 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12484 {
12485 // make sure that we do not directly control the fan for NVidia
12486
12487 gpu_temp_retain = 0;
12488
12489 data.gpu_temp_retain = gpu_temp_retain;
12490 }
12491 #endif // HAVE_NVML || HAVE_NVAPI
12492 #endif
12493 }
12494
12495 /**
12496 * OpenCL devices: simply push all devices from all platforms into the same device array
12497 */
12498
12499 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12500
12501 data.devices_param = devices_param;
12502
12503 uint devices_cnt = 0;
12504
12505 uint devices_active = 0;
12506
12507 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12508 {
12509 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12510
12511 cl_platform_id platform = platforms[platform_id];
12512
12513 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12514
12515 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12516 {
12517 size_t param_value_size = 0;
12518
12519 const uint device_id = devices_cnt;
12520
12521 hc_device_param_t *device_param = &data.devices_param[device_id];
12522
12523 device_param->device = platform_devices[platform_devices_id];
12524
12525 device_param->device_id = device_id;
12526
12527 device_param->platform_devices_id = platform_devices_id;
12528
12529 // device_type
12530
12531 cl_device_type device_type;
12532
12533 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12534
12535 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12536
12537 device_param->device_type = device_type;
12538
12539 // vendor_id
12540
12541 cl_uint vendor_id = 0;
12542
12543 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12544
12545 device_param->vendor_id = vendor_id;
12546
12547 // device_name
12548
12549 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12550
12551 char *device_name = (char *) mymalloc (param_value_size);
12552
12553 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12554
12555 device_param->device_name = device_name;
12556
12557 // tuning db
12558
12559 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12560
12561 // device_version
12562
12563 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12564
12565 char *device_version = (char *) mymalloc (param_value_size);
12566
12567 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12568
12569 device_param->device_version = device_version;
12570
12571 // device_opencl_version
12572
12573 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12574
12575 char *device_opencl_version = (char *) mymalloc (param_value_size);
12576
12577 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12578
12579 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12580
12581 myfree (device_opencl_version);
12582
12583 if (strstr (device_version, "pocl"))
12584 {
12585 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12586 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12587
12588 cl_uint vendor_id = VENDOR_ID_GENERIC;
12589
12590 device_param->vendor_id = vendor_id;
12591 }
12592
12593 // vector_width
12594
12595 cl_uint vector_width;
12596
12597 if (opencl_vector_width_chgd == 0)
12598 {
12599 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12600 {
12601 if (opti_type & OPTI_TYPE_USES_BITS_64)
12602 {
12603 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12604 }
12605 else
12606 {
12607 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12608 }
12609 }
12610 else
12611 {
12612 vector_width = (cl_uint) tuningdb_entry->vector_width;
12613 }
12614 }
12615 else
12616 {
12617 vector_width = opencl_vector_width;
12618 }
12619
12620 if (vector_width > 16) vector_width = 16;
12621
12622 device_param->vector_width = vector_width;
12623
12624 // max_compute_units
12625
12626 cl_uint device_processors;
12627
12628 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12629
12630 device_param->device_processors = device_processors;
12631
12632 // max_mem_alloc_size
12633
12634 cl_ulong device_maxmem_alloc;
12635
12636 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12637
12638 device_param->device_maxmem_alloc = device_maxmem_alloc;
12639
12640 // max_mem_alloc_size
12641
12642 cl_ulong device_global_mem;
12643
12644 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12645
12646 device_param->device_global_mem = device_global_mem;
12647
12648 // max_clock_frequency
12649
12650 cl_uint device_maxclock_frequency;
12651
12652 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12653
12654 device_param->device_maxclock_frequency = device_maxclock_frequency;
12655
12656 // skipped
12657
12658 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12659 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12660
12661 device_param->skipped = (skipped1 || skipped2);
12662
12663 // driver_version
12664 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12665
12666 char *driver_version = (char *) mymalloc (param_value_size);
12667
12668 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12669
12670 device_param->driver_version = driver_version;
12671
12672 // device_name_chksum
12673
12674 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12675
12676 #if __x86_64__
12677 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);
12678 #else
12679 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);
12680 #endif
12681
12682 uint device_name_digest[4] = { 0 };
12683
12684 md5_64 ((uint *) device_name_chksum, device_name_digest);
12685
12686 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12687
12688 device_param->device_name_chksum = device_name_chksum;
12689
12690 // device_processor_cores
12691
12692 if (device_type & CL_DEVICE_TYPE_CPU)
12693 {
12694 cl_uint device_processor_cores = 1;
12695
12696 device_param->device_processor_cores = device_processor_cores;
12697 }
12698
12699 if (device_type & CL_DEVICE_TYPE_GPU)
12700 {
12701 if (vendor_id == VENDOR_ID_AMD)
12702 {
12703 cl_uint device_processor_cores = 0;
12704
12705 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12706
12707 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12708
12709 device_param->device_processor_cores = device_processor_cores;
12710 }
12711 else if (vendor_id == VENDOR_ID_NV)
12712 {
12713 cl_uint kernel_exec_timeout = 0;
12714
12715 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12716
12717 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12718
12719 device_param->kernel_exec_timeout = kernel_exec_timeout;
12720
12721 cl_uint device_processor_cores = 0;
12722
12723 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12724
12725 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12726
12727 device_param->device_processor_cores = device_processor_cores;
12728
12729 cl_uint sm_minor = 0;
12730 cl_uint sm_major = 0;
12731
12732 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12733 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12734
12735 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12736 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12737
12738 device_param->sm_minor = sm_minor;
12739 device_param->sm_major = sm_major;
12740 }
12741 else
12742 {
12743 cl_uint device_processor_cores = 1;
12744
12745 device_param->device_processor_cores = device_processor_cores;
12746 }
12747 }
12748
12749 // display results
12750
12751 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12752 {
12753 if (device_param->skipped == 0)
12754 {
12755 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12756 device_id + 1,
12757 device_name,
12758 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12759 (unsigned int) (device_global_mem / 1024 / 1024),
12760 (unsigned int) (device_maxclock_frequency),
12761 (unsigned int) device_processors);
12762 }
12763 else
12764 {
12765 log_info ("Device #%u: %s, skipped",
12766 device_id + 1,
12767 device_name);
12768 }
12769 }
12770
12771 // common driver check
12772
12773 if (device_param->skipped == 0)
12774 {
12775 if (strstr (device_version, "pocl"))
12776 {
12777 if (force == 0)
12778 {
12779 log_info ("");
12780 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12781 log_info ("You are STRONGLY encouraged not to use it");
12782 log_info ("You can use --force to override this but do not post error reports if you do so");
12783 log_info ("");
12784
12785 return (-1);
12786 }
12787 }
12788
12789 if (device_type & CL_DEVICE_TYPE_GPU)
12790 {
12791 if (vendor_id == VENDOR_ID_NV)
12792 {
12793 if (device_param->kernel_exec_timeout != 0)
12794 {
12795 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);
12796 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12797 }
12798 }
12799 else if (vendor_id == VENDOR_ID_AMD)
12800 {
12801 int catalyst_check = (force == 1) ? 0 : 1;
12802
12803 int catalyst_warn = 0;
12804
12805 int catalyst_broken = 0;
12806
12807 if (catalyst_check == 1)
12808 {
12809 catalyst_warn = 1;
12810
12811 // v14.9 and higher
12812 if (atoi (device_param->driver_version) >= 1573)
12813 {
12814 catalyst_warn = 0;
12815 }
12816
12817 catalyst_check = 0;
12818 }
12819
12820 if (catalyst_broken == 1)
12821 {
12822 log_info ("");
12823 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12824 log_info ("It will pass over cracked hashes and does not report them as cracked");
12825 log_info ("You are STRONGLY encouraged not to use it");
12826 log_info ("You can use --force to override this but do not post error reports if you do so");
12827 log_info ("");
12828
12829 return (-1);
12830 }
12831
12832 if (catalyst_warn == 1)
12833 {
12834 log_info ("");
12835 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12836 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12837 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12838 #ifdef _WIN
12839 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12840 #endif
12841 log_info ("You can use --force to override this but do not post error reports if you do so");
12842 log_info ("");
12843
12844 return (-1);
12845 }
12846 }
12847 }
12848
12849 /**
12850 * kernel accel and loops tuning db adjustment
12851 */
12852
12853 device_param->kernel_accel_min = 1;
12854 device_param->kernel_accel_max = 1024;
12855
12856 device_param->kernel_loops_min = 1;
12857 device_param->kernel_loops_max = 1024;
12858
12859 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12860
12861 if (tuningdb_entry)
12862 {
12863 u32 _kernel_accel = tuningdb_entry->kernel_accel;
12864 u32 _kernel_loops = tuningdb_entry->kernel_loops;
12865
12866 if (_kernel_accel)
12867 {
12868 device_param->kernel_accel_min = _kernel_accel;
12869 device_param->kernel_accel_max = _kernel_accel;
12870 }
12871
12872 if (_kernel_loops)
12873 {
12874 if (workload_profile == 1)
12875 {
12876 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
12877 }
12878 else if (workload_profile == 2)
12879 {
12880 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
12881 }
12882
12883 device_param->kernel_loops_min = _kernel_loops;
12884 device_param->kernel_loops_max = _kernel_loops;
12885 }
12886 }
12887
12888 // commandline parameters overwrite tuningdb entries
12889
12890 if (kernel_accel)
12891 {
12892 device_param->kernel_accel_min = kernel_accel;
12893 device_param->kernel_accel_max = kernel_accel;
12894 }
12895
12896 if (kernel_loops)
12897 {
12898 device_param->kernel_loops_min = kernel_loops;
12899 device_param->kernel_loops_max = kernel_loops;
12900 }
12901
12902 /**
12903 * activate device
12904 */
12905
12906 devices_active++;
12907 }
12908
12909 // next please
12910
12911 devices_cnt++;
12912 }
12913 }
12914
12915 if (keyspace == 0 && devices_active == 0)
12916 {
12917 log_error ("ERROR: No devices found/left");
12918
12919 return (-1);
12920 }
12921
12922 data.devices_cnt = devices_cnt;
12923
12924 data.devices_active = devices_active;
12925
12926 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12927 {
12928 log_info ("");
12929 }
12930
12931 /**
12932 * HM devices: init
12933 */
12934
12935 #ifdef HAVE_HWMON
12936 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12937 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12938 #endif
12939
12940 #ifdef HAVE_ADL
12941 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12942 #endif
12943
12944 if (gpu_temp_disable == 0)
12945 {
12946 #if defined(WIN) && defined(HAVE_NVAPI)
12947 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
12948
12949 if (nvapi_init (nvapi) == 0)
12950 data.hm_nv = nvapi;
12951
12952 if (data.hm_nv)
12953 {
12954 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
12955 {
12956 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
12957
12958 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12959
12960 int tmp_out = 0;
12961
12962 for (int i = 0; i < tmp_in; i++)
12963 {
12964 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12965 }
12966
12967 for (int i = 0; i < tmp_out; i++)
12968 {
12969 NV_GPU_COOLER_SETTINGS pCoolerSettings;
12970
12971 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
12972
12973 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;
12974 }
12975 }
12976 }
12977 #endif // WIN && HAVE_NVAPI
12978
12979 #if defined(LINUX) && defined(HAVE_NVML)
12980 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
12981
12982 if (nvml_init (nvml) == 0)
12983 data.hm_nv = nvml;
12984
12985 if (data.hm_nv)
12986 {
12987 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
12988 {
12989 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
12990
12991 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12992
12993 int tmp_out = 0;
12994
12995 for (int i = 0; i < tmp_in; i++)
12996 {
12997 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12998 }
12999
13000 for (int i = 0; i < tmp_out; i++)
13001 {
13002 unsigned int speed;
13003
13004 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;
13005 }
13006 }
13007 }
13008 #endif // LINUX && HAVE_NVML
13009
13010 data.hm_amd = NULL;
13011
13012 #ifdef HAVE_ADL
13013 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13014
13015 if (adl_init (adl) == 0)
13016 data.hm_amd = adl;
13017
13018 if (data.hm_amd)
13019 {
13020 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13021 {
13022 // total number of adapters
13023
13024 int hm_adapters_num;
13025
13026 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13027
13028 // adapter info
13029
13030 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13031
13032 if (lpAdapterInfo == NULL) return (-1);
13033
13034 // get a list (of ids of) valid/usable adapters
13035
13036 int num_adl_adapters = 0;
13037
13038 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13039
13040 if (num_adl_adapters > 0)
13041 {
13042 hc_thread_mutex_lock (mux_adl);
13043
13044 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13045
13046 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13047
13048 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13049 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13050
13051 hc_thread_mutex_unlock (mux_adl);
13052 }
13053
13054 myfree (valid_adl_device_list);
13055 myfree (lpAdapterInfo);
13056 }
13057 }
13058 #endif // HAVE_ADL
13059
13060 if (data.hm_amd == NULL && data.hm_nv == NULL)
13061 {
13062 gpu_temp_disable = 1;
13063 }
13064 }
13065
13066 /**
13067 * OpenCL devices: allocate buffer for device specific information
13068 */
13069
13070 #ifdef HAVE_HWMON
13071 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13072
13073 #ifdef HAVE_ADL
13074 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13075
13076 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13077 #endif // ADL
13078 #endif
13079
13080 /**
13081 * enable custom signal handler(s)
13082 */
13083
13084 if (benchmark == 0)
13085 {
13086 hc_signal (sigHandler_default);
13087 }
13088 else
13089 {
13090 hc_signal (sigHandler_benchmark);
13091 }
13092
13093 /**
13094 * User-defined GPU temp handling
13095 */
13096
13097 #ifdef HAVE_HWMON
13098 if (gpu_temp_disable == 1)
13099 {
13100 gpu_temp_abort = 0;
13101 gpu_temp_retain = 0;
13102 }
13103
13104 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13105 {
13106 if (gpu_temp_abort < gpu_temp_retain)
13107 {
13108 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13109
13110 return (-1);
13111 }
13112 }
13113
13114 data.gpu_temp_disable = gpu_temp_disable;
13115 data.gpu_temp_abort = gpu_temp_abort;
13116 data.gpu_temp_retain = gpu_temp_retain;
13117 #endif
13118
13119 /**
13120 * inform the user
13121 */
13122
13123 if (data.quiet == 0)
13124 {
13125 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13126
13127 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);
13128
13129 if (attack_mode == ATTACK_MODE_STRAIGHT)
13130 {
13131 log_info ("Rules: %u", kernel_rules_cnt);
13132 }
13133
13134 if (opti_type)
13135 {
13136 log_info ("Applicable Optimizers:");
13137
13138 for (uint i = 0; i < 32; i++)
13139 {
13140 const uint opti_bit = 1u << i;
13141
13142 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13143 }
13144 }
13145
13146 /**
13147 * Watchdog and Temperature balance
13148 */
13149
13150 #ifdef HAVE_HWMON
13151 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13152 {
13153 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13154 }
13155
13156 if (gpu_temp_abort == 0)
13157 {
13158 log_info ("Watchdog: Temperature abort trigger disabled");
13159 }
13160 else
13161 {
13162 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13163 }
13164
13165 if (gpu_temp_retain == 0)
13166 {
13167 log_info ("Watchdog: Temperature retain trigger disabled");
13168 }
13169 else
13170 {
13171 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13172 }
13173 #endif
13174 }
13175
13176 if (data.quiet == 0) log_info ("");
13177
13178 /**
13179 * HM devices: copy
13180 */
13181
13182 if (gpu_temp_disable == 0)
13183 {
13184 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13185 {
13186 hc_device_param_t *device_param = &data.devices_param[device_id];
13187
13188 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13189
13190 if (device_param->skipped) continue;
13191
13192 const uint platform_devices_id = device_param->platform_devices_id;
13193
13194 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13195 if (device_param->vendor_id == VENDOR_ID_NV)
13196 {
13197 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13198 }
13199 #endif
13200
13201 #ifdef HAVE_ADL
13202 if (device_param->vendor_id == VENDOR_ID_AMD)
13203 {
13204 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13205 }
13206 #endif
13207 }
13208 }
13209
13210 /*
13211 * Temporary fix:
13212 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13213 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13214 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13215 * Driver / ADL bug?
13216 */
13217
13218 #ifdef HAVE_ADL
13219 if (powertune_enable == 1)
13220 {
13221 hc_thread_mutex_lock (mux_adl);
13222
13223 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13224 {
13225 hc_device_param_t *device_param = &data.devices_param[device_id];
13226
13227 if (device_param->skipped) continue;
13228
13229 if (data.hm_device[device_id].od_version == 6)
13230 {
13231 // set powertune value only
13232
13233 int powertune_supported = 0;
13234
13235 int ADL_rc = 0;
13236
13237 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13238 {
13239 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13240
13241 return (-1);
13242 }
13243
13244 if (powertune_supported != 0)
13245 {
13246 // powertune set
13247 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13248
13249 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13250 {
13251 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13252
13253 return (-1);
13254 }
13255
13256 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13257 {
13258 log_error ("ERROR: Failed to set new ADL PowerControl values");
13259
13260 return (-1);
13261 }
13262 }
13263 }
13264 }
13265
13266 hc_thread_mutex_unlock (mux_adl);
13267 }
13268 #endif // HAVE_ADK
13269 #endif // HAVE_HWMON
13270
13271 #ifdef DEBUG
13272 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13273 #endif
13274
13275 uint kernel_power_all = 0;
13276
13277 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13278 {
13279 /**
13280 * host buffer
13281 */
13282
13283 hc_device_param_t *device_param = &data.devices_param[device_id];
13284
13285 if (device_param->skipped) continue;
13286
13287 /**
13288 * device properties
13289 */
13290
13291 const char *device_name_chksum = device_param->device_name_chksum;
13292 const u32 device_processors = device_param->device_processors;
13293 const u32 device_processor_cores = device_param->device_processor_cores;
13294
13295 /**
13296 * create context for each device
13297 */
13298
13299 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13300
13301 /**
13302 * create command-queue
13303 */
13304
13305 // not supported with NV
13306 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13307
13308 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13309
13310 /**
13311 * create input buffers on device : calculate size of fixed memory buffers
13312 */
13313
13314 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13315 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13316
13317 device_param->size_root_css = size_root_css;
13318 device_param->size_markov_css = size_markov_css;
13319
13320 uint size_results = KERNEL_THREADS * sizeof (uint);
13321
13322 device_param->size_results = size_results;
13323
13324 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13325 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13326
13327 uint size_plains = digests_cnt * sizeof (plain_t);
13328 uint size_salts = salts_cnt * sizeof (salt_t);
13329 uint size_esalts = salts_cnt * esalt_size;
13330
13331 device_param->size_plains = size_plains;
13332 device_param->size_digests = size_digests;
13333 device_param->size_shown = size_shown;
13334 device_param->size_salts = size_salts;
13335
13336 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13337 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13338 uint size_tm = 32 * sizeof (bs_word_t);
13339
13340 // scryptV stuff
13341
13342 u64 size_scryptV = 1;
13343
13344 if ((hash_mode == 8900) || (hash_mode == 9300))
13345 {
13346 uint tmto_start = 0;
13347 uint tmto_stop = 10;
13348
13349 if (scrypt_tmto)
13350 {
13351 tmto_start = scrypt_tmto;
13352 }
13353 else
13354 {
13355 // in case the user did not specify the tmto manually
13356 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13357 // but set the lower end only in case the user has a device with too less memory
13358
13359 if (hash_mode == 8900)
13360 {
13361 if (device_param->vendor_id == VENDOR_ID_AMD)
13362 {
13363 tmto_start = 1;
13364 }
13365 else if (device_param->vendor_id == VENDOR_ID_NV)
13366 {
13367 tmto_start = 3;
13368 }
13369 }
13370 else if (hash_mode == 9300)
13371 {
13372 if (device_param->vendor_id == VENDOR_ID_AMD)
13373 {
13374 tmto_start = 3;
13375 }
13376 else if (device_param->vendor_id == VENDOR_ID_NV)
13377 {
13378 tmto_start = 5;
13379 }
13380 }
13381 }
13382
13383 if (quiet == 0) log_info ("");
13384
13385 uint shader_per_mp = 1;
13386
13387 if (device_param->vendor_id == VENDOR_ID_AMD)
13388 {
13389 shader_per_mp = 8;
13390 }
13391 else if (device_param->vendor_id == VENDOR_ID_NV)
13392 {
13393 shader_per_mp = 32;
13394 }
13395
13396 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13397 {
13398 // TODO: in theory the following calculation needs to be done per salt, not global
13399 // we assume all hashes have the same scrypt settings
13400
13401 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13402
13403 size_scryptV /= 1 << tmto;
13404
13405 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13406
13407 if (size_scryptV > device_param->device_maxmem_alloc)
13408 {
13409 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13410
13411 continue;
13412 }
13413
13414 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13415 {
13416 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13417 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13418 }
13419
13420 break;
13421 }
13422
13423 if (data.salts_buf[0].scrypt_phy == 0)
13424 {
13425 log_error ("ERROR: can't allocate enough device memory");
13426
13427 return -1;
13428 }
13429
13430 if (quiet == 0) log_info ("");
13431 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13432 }
13433
13434 /**
13435 * create input buffers on device : calculate size of dynamic size memory buffers
13436 */
13437
13438 uint kernel_threads = KERNEL_THREADS;
13439
13440 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13441
13442 if (hash_mode == 3200) kernel_threads = 8;
13443 if (hash_mode == 9000) kernel_threads = 8;
13444
13445 /**
13446 * some algorithms need a fixed kernel-loops count
13447 */
13448
13449 if (hash_mode == 1500)
13450 {
13451 const u32 kernel_loops_fixed = 1024;
13452
13453 device_param->kernel_loops_min = kernel_loops_fixed;
13454 device_param->kernel_loops_max = kernel_loops_fixed;
13455 }
13456
13457 if (hash_mode == 3000)
13458 {
13459 const u32 kernel_loops_fixed = 1024;
13460
13461 device_param->kernel_loops_min = kernel_loops_fixed;
13462 device_param->kernel_loops_max = kernel_loops_fixed;
13463 }
13464
13465 if (hash_mode == 8900)
13466 {
13467 const u32 kernel_loops_fixed = 1;
13468
13469 device_param->kernel_loops_min = kernel_loops_fixed;
13470 device_param->kernel_loops_max = kernel_loops_fixed;
13471 }
13472
13473 if (hash_mode == 9300)
13474 {
13475 const u32 kernel_loops_fixed = 1;
13476
13477 device_param->kernel_loops_min = kernel_loops_fixed;
13478 device_param->kernel_loops_max = kernel_loops_fixed;
13479 }
13480
13481 if (hash_mode == 12500)
13482 {
13483 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13484
13485 device_param->kernel_loops_min = kernel_loops_fixed;
13486 device_param->kernel_loops_max = kernel_loops_fixed;
13487 }
13488
13489 /**
13490 * some algorithms have a maximum kernel-loops count
13491 */
13492
13493 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13494 {
13495 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13496 {
13497 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13498 }
13499 }
13500
13501 /**
13502 * some algorithms need a special kernel-accel
13503 */
13504
13505 if (hash_mode == 8900)
13506 {
13507 device_param->kernel_accel_min = 1;
13508 device_param->kernel_accel_max = 64;
13509 }
13510
13511 if (hash_mode == 9300)
13512 {
13513 device_param->kernel_accel_min = 1;
13514 device_param->kernel_accel_max = 64;
13515 }
13516
13517 u32 kernel_accel_min = device_param->kernel_accel_min;
13518 u32 kernel_accel_max = device_param->kernel_accel_max;
13519
13520 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13521
13522 uint size_pws = 4;
13523 uint size_tmps = 4;
13524 uint size_hooks = 4;
13525
13526 while (kernel_accel_max >= kernel_accel_min)
13527 {
13528 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13529
13530 // size_pws
13531
13532 size_pws = kernel_power_max * sizeof (pw_t);
13533
13534 // size_tmps
13535
13536 switch (hash_mode)
13537 {
13538 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13539 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13540 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13541 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13542 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13543 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13544 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13545 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13546 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13547 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13548 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13549 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13550 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13551 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13552 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13553 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13554 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13555 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13556 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13557 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13558 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13559 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13560 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13561 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13562 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13563 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13564 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13565 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13566 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13567 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13568 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13569 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13570 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13571 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13572 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13573 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13574 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13575 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13576 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13577 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13578 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13579 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13580 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13581 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13582 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13583 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13584 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13585 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13586 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13587 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13588 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13589 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13590 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13591 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13592 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13593 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13594 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13595 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13596 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13597 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13598 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13599 };
13600
13601 // size_hooks
13602
13603 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13604 {
13605 // none yet
13606 }
13607
13608 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13609 // if not, decrease amplifier and try again
13610
13611 int skip = 0;
13612
13613 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13614 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13615 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13616
13617 if (( bitmap_size
13618 + bitmap_size
13619 + bitmap_size
13620 + bitmap_size
13621 + bitmap_size
13622 + bitmap_size
13623 + bitmap_size
13624 + bitmap_size
13625 + size_bfs
13626 + size_combs
13627 + size_digests
13628 + size_esalts
13629 + size_hooks
13630 + size_markov_css
13631 + size_plains
13632 + size_pws
13633 + size_results
13634 + size_root_css
13635 + size_rules
13636 + size_rules_c
13637 + size_salts
13638 + size_scryptV
13639 + size_shown
13640 + size_tm
13641 + size_tmps) > device_param->device_global_mem) skip = 1;
13642
13643 if (skip == 1)
13644 {
13645 kernel_accel_max--;
13646
13647 continue;
13648 }
13649
13650 break;
13651 }
13652
13653 /*
13654 if (kernel_accel_max == 0)
13655 {
13656 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13657
13658 return -1;
13659 }
13660 */
13661
13662 device_param->kernel_accel_min = kernel_accel_min;
13663 device_param->kernel_accel_max = kernel_accel_max;
13664
13665 /*
13666 if (kernel_accel_max < kernel_accel)
13667 {
13668 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13669
13670 device_param->kernel_accel = kernel_accel_max;
13671 }
13672 */
13673
13674 device_param->size_pws = size_pws;
13675 device_param->size_tmps = size_tmps;
13676 device_param->size_hooks = size_hooks;
13677
13678 // do not confuse kernel_accel_max with kernel_accel here
13679
13680 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13681
13682 device_param->kernel_threads = kernel_threads;
13683 device_param->kernel_power_user = kernel_power;
13684
13685 kernel_power_all += kernel_power;
13686
13687 /**
13688 * default building options
13689 */
13690
13691 char build_opts[1024] = { 0 };
13692
13693 // we don't have sm_* on vendors not NV but it doesn't matter
13694
13695 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);
13696
13697 /**
13698 * main kernel
13699 */
13700
13701 {
13702 /**
13703 * kernel source filename
13704 */
13705
13706 char source_file[256] = { 0 };
13707
13708 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13709
13710 struct stat sst;
13711
13712 if (stat (source_file, &sst) == -1)
13713 {
13714 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13715
13716 return -1;
13717 }
13718
13719 /**
13720 * kernel cached filename
13721 */
13722
13723 char cached_file[256] = { 0 };
13724
13725 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13726
13727 int cached = 1;
13728
13729 struct stat cst;
13730
13731 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13732 {
13733 cached = 0;
13734 }
13735
13736 /**
13737 * kernel compile or load
13738 */
13739
13740 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13741
13742 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13743
13744 if (force_jit_compilation == -1)
13745 {
13746 if (cached == 0)
13747 {
13748 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13749
13750 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13751
13752 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13753
13754 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13755
13756 if (rc != 0)
13757 {
13758 device_param->skipped = true;
13759 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13760 continue;
13761 }
13762
13763 size_t binary_size;
13764
13765 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13766
13767 u8 *binary = (u8 *) mymalloc (binary_size);
13768
13769 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13770
13771 writeProgramBin (cached_file, binary, binary_size);
13772
13773 local_free (binary);
13774 }
13775 else
13776 {
13777 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13778
13779 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13780
13781 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13782
13783 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13784 }
13785 }
13786 else
13787 {
13788 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13789
13790 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13791
13792 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13793
13794 char build_opts_update[1024] = { 0 };
13795
13796 if (force_jit_compilation == 1500)
13797 {
13798 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13799 }
13800 else if (force_jit_compilation == 8900)
13801 {
13802 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);
13803 }
13804 else
13805 {
13806 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
13807 }
13808
13809 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13810
13811 if (rc != 0)
13812 {
13813 device_param->skipped = true;
13814
13815 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13816 }
13817 }
13818
13819 local_free (kernel_lengths);
13820 local_free (kernel_sources[0]);
13821 local_free (kernel_sources);
13822 }
13823
13824 /**
13825 * word generator kernel
13826 */
13827
13828 if (attack_mode != ATTACK_MODE_STRAIGHT)
13829 {
13830 /**
13831 * kernel mp source filename
13832 */
13833
13834 char source_file[256] = { 0 };
13835
13836 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13837
13838 struct stat sst;
13839
13840 if (stat (source_file, &sst) == -1)
13841 {
13842 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13843
13844 return -1;
13845 }
13846
13847 /**
13848 * kernel mp cached filename
13849 */
13850
13851 char cached_file[256] = { 0 };
13852
13853 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13854
13855 int cached = 1;
13856
13857 struct stat cst;
13858
13859 if (stat (cached_file, &cst) == -1)
13860 {
13861 cached = 0;
13862 }
13863
13864 /**
13865 * kernel compile or load
13866 */
13867
13868 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13869
13870 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13871
13872 if (cached == 0)
13873 {
13874 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13875
13876 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13877
13878 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13879
13880 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
13881
13882 if (rc != 0)
13883 {
13884 device_param->skipped = true;
13885 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13886 continue;
13887 }
13888
13889 size_t binary_size;
13890
13891 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13892
13893 u8 *binary = (u8 *) mymalloc (binary_size);
13894
13895 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13896
13897 writeProgramBin (cached_file, binary, binary_size);
13898
13899 local_free (binary);
13900 }
13901 else
13902 {
13903 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13904
13905 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13906
13907 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13908
13909 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
13910 }
13911
13912 local_free (kernel_lengths);
13913 local_free (kernel_sources[0]);
13914 local_free (kernel_sources);
13915 }
13916
13917 /**
13918 * amplifier kernel
13919 */
13920
13921 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13922 {
13923
13924 }
13925 else
13926 {
13927 /**
13928 * kernel amp source filename
13929 */
13930
13931 char source_file[256] = { 0 };
13932
13933 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13934
13935 struct stat sst;
13936
13937 if (stat (source_file, &sst) == -1)
13938 {
13939 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13940
13941 return -1;
13942 }
13943
13944 /**
13945 * kernel amp cached filename
13946 */
13947
13948 char cached_file[256] = { 0 };
13949
13950 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13951
13952 int cached = 1;
13953
13954 struct stat cst;
13955
13956 if (stat (cached_file, &cst) == -1)
13957 {
13958 cached = 0;
13959 }
13960
13961 /**
13962 * kernel compile or load
13963 */
13964
13965 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13966
13967 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13968
13969 if (cached == 0)
13970 {
13971 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13972
13973 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13974
13975 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13976
13977 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
13978
13979 if (rc != 0)
13980 {
13981 device_param->skipped = true;
13982 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13983 continue;
13984 }
13985
13986 size_t binary_size;
13987
13988 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13989
13990 u8 *binary = (u8 *) mymalloc (binary_size);
13991
13992 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13993
13994 writeProgramBin (cached_file, binary, binary_size);
13995
13996 local_free (binary);
13997 }
13998 else
13999 {
14000 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14001
14002 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14003
14004 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14005
14006 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14007 }
14008
14009 local_free (kernel_lengths);
14010 local_free (kernel_sources[0]);
14011 local_free (kernel_sources);
14012 }
14013
14014 // some algorithm collide too fast, make that impossible
14015
14016 if (benchmark == 1)
14017 {
14018 ((uint *) digests_buf)[0] = -1;
14019 ((uint *) digests_buf)[1] = -1;
14020 ((uint *) digests_buf)[2] = -1;
14021 ((uint *) digests_buf)[3] = -1;
14022 }
14023
14024 /**
14025 * global buffers
14026 */
14027
14028 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14029 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14030 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14031 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14032 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14033 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14034 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14035 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14036 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14037 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14038 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14039 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14040 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14041 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14042 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14043 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14044 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14045 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14046
14047 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);
14048 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);
14049 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);
14050 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);
14051 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);
14052 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);
14053 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);
14054 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);
14055 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14056 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14057 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14058
14059 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14060 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14061 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14062 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14063 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14064 run_kernel_bzero (device_param, device_param->d_result, size_results);
14065
14066 /**
14067 * special buffers
14068 */
14069
14070 if (attack_kern == ATTACK_KERN_STRAIGHT)
14071 {
14072 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14073 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14074
14075 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14076
14077 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14078 }
14079 else if (attack_kern == ATTACK_KERN_COMBI)
14080 {
14081 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14082 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14083 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14084 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14085
14086 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14087 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14088 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14089 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14090 }
14091 else if (attack_kern == ATTACK_KERN_BF)
14092 {
14093 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14094 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14095 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14096 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14097 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14098
14099 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14100 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14101 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14102 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14103 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14104 }
14105
14106 if (size_esalts)
14107 {
14108 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14109
14110 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14111 }
14112
14113 /**
14114 * main host data
14115 */
14116
14117 uint *result = (uint *) mymalloc (size_results);
14118
14119 device_param->result = result;
14120
14121 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14122
14123 device_param->pws_buf = pws_buf;
14124
14125 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14126
14127 device_param->combs_buf = combs_buf;
14128
14129 void *hooks_buf = mymalloc (size_hooks);
14130
14131 device_param->hooks_buf = hooks_buf;
14132
14133 /**
14134 * kernel args
14135 */
14136
14137 device_param->kernel_params_buf32[21] = bitmap_mask;
14138 device_param->kernel_params_buf32[22] = bitmap_shift1;
14139 device_param->kernel_params_buf32[23] = bitmap_shift2;
14140 device_param->kernel_params_buf32[24] = 0; // salt_pos
14141 device_param->kernel_params_buf32[25] = 0; // loop_pos
14142 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14143 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14144 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14145 device_param->kernel_params_buf32[29] = 0; // digests_offset
14146 device_param->kernel_params_buf32[30] = 0; // combs_mode
14147 device_param->kernel_params_buf32[31] = 0; // gid_max
14148
14149 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14150 ? &device_param->d_pws_buf
14151 : &device_param->d_pws_amp_buf;
14152 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14153 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14154 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14155 device_param->kernel_params[ 4] = &device_param->d_tmps;
14156 device_param->kernel_params[ 5] = &device_param->d_hooks;
14157 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14158 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14159 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14160 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14161 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14162 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14163 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14164 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14165 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14166 device_param->kernel_params[15] = &device_param->d_digests_buf;
14167 device_param->kernel_params[16] = &device_param->d_digests_shown;
14168 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14169 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14170 device_param->kernel_params[19] = &device_param->d_result;
14171 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14172 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14173 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14174 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14175 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14176 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14177 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14178 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14179 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14180 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14181 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14182 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14183
14184 device_param->kernel_params_mp_buf64[3] = 0;
14185 device_param->kernel_params_mp_buf32[4] = 0;
14186 device_param->kernel_params_mp_buf32[5] = 0;
14187 device_param->kernel_params_mp_buf32[6] = 0;
14188 device_param->kernel_params_mp_buf32[7] = 0;
14189 device_param->kernel_params_mp_buf32[8] = 0;
14190
14191 device_param->kernel_params_mp[0] = NULL;
14192 device_param->kernel_params_mp[1] = NULL;
14193 device_param->kernel_params_mp[2] = NULL;
14194 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14195 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14196 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14197 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14198 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14199 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14200
14201 device_param->kernel_params_mp_l_buf64[3] = 0;
14202 device_param->kernel_params_mp_l_buf32[4] = 0;
14203 device_param->kernel_params_mp_l_buf32[5] = 0;
14204 device_param->kernel_params_mp_l_buf32[6] = 0;
14205 device_param->kernel_params_mp_l_buf32[7] = 0;
14206 device_param->kernel_params_mp_l_buf32[8] = 0;
14207 device_param->kernel_params_mp_l_buf32[9] = 0;
14208
14209 device_param->kernel_params_mp_l[0] = NULL;
14210 device_param->kernel_params_mp_l[1] = NULL;
14211 device_param->kernel_params_mp_l[2] = NULL;
14212 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14213 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14214 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14215 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14216 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14217 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14218 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14219
14220 device_param->kernel_params_mp_r_buf64[3] = 0;
14221 device_param->kernel_params_mp_r_buf32[4] = 0;
14222 device_param->kernel_params_mp_r_buf32[5] = 0;
14223 device_param->kernel_params_mp_r_buf32[6] = 0;
14224 device_param->kernel_params_mp_r_buf32[7] = 0;
14225 device_param->kernel_params_mp_r_buf32[8] = 0;
14226
14227 device_param->kernel_params_mp_r[0] = NULL;
14228 device_param->kernel_params_mp_r[1] = NULL;
14229 device_param->kernel_params_mp_r[2] = NULL;
14230 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14231 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14232 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14233 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14234 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14235 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14236
14237 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14238 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14239
14240 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14241 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14242 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14243 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14244 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14245 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14246 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14247
14248 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14249
14250 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14251 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14252
14253 /**
14254 * kernel name
14255 */
14256
14257 char kernel_name[64] = { 0 };
14258
14259 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14260 {
14261 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14262 {
14263 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14264
14265 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14266
14267 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14268
14269 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14270
14271 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14272
14273 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14274 }
14275 else
14276 {
14277 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14278
14279 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14280
14281 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14282
14283 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14284
14285 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14286
14287 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14288 }
14289
14290 if (data.attack_mode == ATTACK_MODE_BF)
14291 {
14292 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14293 {
14294 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14295
14296 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14297
14298 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14299
14300 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14301 }
14302 }
14303 }
14304 else
14305 {
14306 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14307
14308 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14309
14310 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14311
14312 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14313
14314 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14315
14316 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14317
14318 if (opts_type & OPTS_TYPE_HOOK12)
14319 {
14320 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14321
14322 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14323 }
14324
14325 if (opts_type & OPTS_TYPE_HOOK23)
14326 {
14327 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14328
14329 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14330 }
14331 }
14332
14333 for (uint i = 0; i <= 20; i++)
14334 {
14335 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14336 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14337 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14338
14339 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14340 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14341 }
14342
14343 for (uint i = 21; i <= 31; i++)
14344 {
14345 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14346 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14347 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14348
14349 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14350 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14351 }
14352
14353 if (attack_mode == ATTACK_MODE_BF)
14354 {
14355 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14356 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14357
14358 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14359 {
14360 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14361
14362 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14363 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14364 }
14365 }
14366 else if (attack_mode == ATTACK_MODE_HYBRID1)
14367 {
14368 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14369 }
14370 else if (attack_mode == ATTACK_MODE_HYBRID2)
14371 {
14372 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14373 }
14374
14375 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14376 {
14377 // nothing to do
14378 }
14379 else
14380 {
14381 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14382 }
14383
14384 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14385 {
14386 // nothing to do
14387 }
14388 else
14389 {
14390 for (uint i = 0; i < 5; i++)
14391 {
14392 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14393 }
14394
14395 for (uint i = 5; i < 7; i++)
14396 {
14397 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14398 }
14399 }
14400
14401 /**
14402 * Store initial fanspeed if gpu_temp_retain is enabled
14403 */
14404
14405 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14406 int gpu_temp_retain_set = 0;
14407
14408 if (gpu_temp_disable == 0)
14409 {
14410 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14411 {
14412 hc_thread_mutex_lock (mux_adl);
14413
14414 if (data.hm_device[device_id].fan_supported == 1)
14415 {
14416 if (gpu_temp_retain_chgd == 0)
14417 {
14418 uint cur_temp = 0;
14419 uint default_temp = 0;
14420
14421 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);
14422
14423 if (ADL_rc == ADL_OK)
14424 {
14425 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14426
14427 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14428
14429 // special case with multi gpu setups: always use minimum retain
14430
14431 if (gpu_temp_retain_set == 0)
14432 {
14433 gpu_temp_retain = gpu_temp_retain_target;
14434 gpu_temp_retain_set = 1;
14435 }
14436 else
14437 {
14438 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14439 }
14440
14441 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14442 }
14443 }
14444
14445 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14446
14447 temp_retain_fanspeed_value[device_id] = fan_speed;
14448
14449 if (fan_speed == -1)
14450 {
14451 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14452
14453 temp_retain_fanspeed_value[device_id] = 0;
14454 }
14455 }
14456
14457 hc_thread_mutex_unlock (mux_adl);
14458 }
14459 }
14460
14461 /**
14462 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14463 */
14464
14465 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14466 {
14467 hc_thread_mutex_lock (mux_adl);
14468
14469 if (data.hm_device[device_id].od_version == 6)
14470 {
14471 int ADL_rc;
14472
14473 // check powertune capabilities first, if not available then skip device
14474
14475 int powertune_supported = 0;
14476
14477 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14478 {
14479 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14480
14481 return (-1);
14482 }
14483
14484 if (powertune_supported != 0)
14485 {
14486 // powercontrol settings
14487
14488 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14489
14490 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14491 {
14492 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14493 }
14494
14495 if (ADL_rc != ADL_OK)
14496 {
14497 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14498
14499 return (-1);
14500 }
14501
14502 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14503 {
14504 log_error ("ERROR: Failed to set new ADL PowerControl values");
14505
14506 return (-1);
14507 }
14508
14509 // clocks
14510
14511 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14512
14513 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14514
14515 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)
14516 {
14517 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14518
14519 return (-1);
14520 }
14521
14522 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14523
14524 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14525
14526 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14527 {
14528 log_error ("ERROR: Failed to get ADL device capabilities");
14529
14530 return (-1);
14531 }
14532
14533 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14534 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14535
14536 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14537 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14538
14539 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14540 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14541
14542 // warning if profile has too low max values
14543
14544 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14545 {
14546 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14547 }
14548
14549 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14550 {
14551 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14552 }
14553
14554 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14555
14556 performance_state->iNumberOfPerformanceLevels = 2;
14557
14558 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14559 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14560 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14561 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14562
14563 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)
14564 {
14565 log_info ("ERROR: Failed to set ADL performance state");
14566
14567 return (-1);
14568 }
14569
14570 local_free (performance_state);
14571 }
14572 }
14573
14574 hc_thread_mutex_unlock (mux_adl);
14575 }
14576 #endif // HAVE_HWMON && HAVE_ADL
14577 }
14578
14579 data.kernel_power_all = kernel_power_all;
14580
14581 if (data.quiet == 0) log_info ("");
14582
14583 /**
14584 * Inform user which algorithm is checked and at which workload setting
14585 */
14586
14587 if (benchmark == 1)
14588 {
14589 quiet = 0;
14590
14591 data.quiet = quiet;
14592
14593 char *hash_type = strhashtype (data.hash_mode); // not a bug
14594
14595 log_info ("Hashtype: %s", hash_type);
14596 log_info ("");
14597 }
14598
14599 /**
14600 * keep track of the progress
14601 */
14602
14603 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14604 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14605 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14606
14607 /**
14608 * open filehandles
14609 */
14610
14611 #if _WIN
14612 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14613 {
14614 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14615
14616 return (-1);
14617 }
14618
14619 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14620 {
14621 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14622
14623 return (-1);
14624 }
14625
14626 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14627 {
14628 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14629
14630 return (-1);
14631 }
14632 #endif
14633
14634 /**
14635 * dictionary pad
14636 */
14637
14638 segment_size *= (1024 * 1024);
14639
14640 data.segment_size = segment_size;
14641
14642 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14643
14644 wl_data->buf = (char *) mymalloc (segment_size);
14645 wl_data->avail = segment_size;
14646 wl_data->incr = segment_size;
14647 wl_data->cnt = 0;
14648 wl_data->pos = 0;
14649
14650 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14651
14652 data.wordlist_mode = wordlist_mode;
14653
14654 cs_t *css_buf = NULL;
14655 uint css_cnt = 0;
14656 uint dictcnt = 0;
14657 uint maskcnt = 1;
14658 char **masks = NULL;
14659 char **dictfiles = NULL;
14660
14661 uint mask_from_file = 0;
14662
14663 if (attack_mode == ATTACK_MODE_STRAIGHT)
14664 {
14665 if (wordlist_mode == WL_MODE_FILE)
14666 {
14667 int wls_left = myargc - (optind + 1);
14668
14669 for (int i = 0; i < wls_left; i++)
14670 {
14671 char *l0_filename = myargv[optind + 1 + i];
14672
14673 struct stat l0_stat;
14674
14675 if (stat (l0_filename, &l0_stat) == -1)
14676 {
14677 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14678
14679 return (-1);
14680 }
14681
14682 uint is_dir = S_ISDIR (l0_stat.st_mode);
14683
14684 if (is_dir == 0)
14685 {
14686 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14687
14688 dictcnt++;
14689
14690 dictfiles[dictcnt - 1] = l0_filename;
14691 }
14692 else
14693 {
14694 // do not allow --keyspace w/ a directory
14695
14696 if (keyspace == 1)
14697 {
14698 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14699
14700 return (-1);
14701 }
14702
14703 char **dictionary_files = NULL;
14704
14705 dictionary_files = scan_directory (l0_filename);
14706
14707 if (dictionary_files != NULL)
14708 {
14709 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14710
14711 for (int d = 0; dictionary_files[d] != NULL; d++)
14712 {
14713 char *l1_filename = dictionary_files[d];
14714
14715 struct stat l1_stat;
14716
14717 if (stat (l1_filename, &l1_stat) == -1)
14718 {
14719 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14720
14721 return (-1);
14722 }
14723
14724 if (S_ISREG (l1_stat.st_mode))
14725 {
14726 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14727
14728 dictcnt++;
14729
14730 dictfiles[dictcnt - 1] = strdup (l1_filename);
14731 }
14732 }
14733 }
14734
14735 local_free (dictionary_files);
14736 }
14737 }
14738
14739 if (dictcnt < 1)
14740 {
14741 log_error ("ERROR: No usable dictionary file found.");
14742
14743 return (-1);
14744 }
14745 }
14746 else if (wordlist_mode == WL_MODE_STDIN)
14747 {
14748 dictcnt = 1;
14749 }
14750 }
14751 else if (attack_mode == ATTACK_MODE_COMBI)
14752 {
14753 // display
14754
14755 char *dictfile1 = myargv[optind + 1 + 0];
14756 char *dictfile2 = myargv[optind + 1 + 1];
14757
14758 // find the bigger dictionary and use as base
14759
14760 FILE *fp1 = NULL;
14761 FILE *fp2 = NULL;
14762
14763 struct stat tmp_stat;
14764
14765 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14766 {
14767 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14768
14769 return (-1);
14770 }
14771
14772 if (stat (dictfile1, &tmp_stat) == -1)
14773 {
14774 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14775
14776 fclose (fp1);
14777
14778 return (-1);
14779 }
14780
14781 if (S_ISDIR (tmp_stat.st_mode))
14782 {
14783 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14784
14785 fclose (fp1);
14786
14787 return (-1);
14788 }
14789
14790 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14791 {
14792 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14793
14794 fclose (fp1);
14795
14796 return (-1);
14797 }
14798
14799 if (stat (dictfile2, &tmp_stat) == -1)
14800 {
14801 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14802
14803 fclose (fp1);
14804 fclose (fp2);
14805
14806 return (-1);
14807 }
14808
14809 if (S_ISDIR (tmp_stat.st_mode))
14810 {
14811 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14812
14813 fclose (fp1);
14814 fclose (fp2);
14815
14816 return (-1);
14817 }
14818
14819 data.combs_cnt = 1;
14820
14821 data.quiet = 1;
14822
14823 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14824
14825 data.quiet = quiet;
14826
14827 if (words1_cnt == 0)
14828 {
14829 log_error ("ERROR: %s: empty file", dictfile1);
14830
14831 fclose (fp1);
14832 fclose (fp2);
14833
14834 return (-1);
14835 }
14836
14837 data.combs_cnt = 1;
14838
14839 data.quiet = 1;
14840
14841 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14842
14843 data.quiet = quiet;
14844
14845 if (words2_cnt == 0)
14846 {
14847 log_error ("ERROR: %s: empty file", dictfile2);
14848
14849 fclose (fp1);
14850 fclose (fp2);
14851
14852 return (-1);
14853 }
14854
14855 fclose (fp1);
14856 fclose (fp2);
14857
14858 data.dictfile = dictfile1;
14859 data.dictfile2 = dictfile2;
14860
14861 if (words1_cnt >= words2_cnt)
14862 {
14863 data.combs_cnt = words2_cnt;
14864 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14865
14866 dictfiles = &data.dictfile;
14867
14868 dictcnt = 1;
14869 }
14870 else
14871 {
14872 data.combs_cnt = words1_cnt;
14873 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14874
14875 dictfiles = &data.dictfile2;
14876
14877 dictcnt = 1;
14878
14879 // we also have to switch wordlist related rules!
14880
14881 char *tmpc = data.rule_buf_l;
14882
14883 data.rule_buf_l = data.rule_buf_r;
14884 data.rule_buf_r = tmpc;
14885
14886 int tmpi = data.rule_len_l;
14887
14888 data.rule_len_l = data.rule_len_r;
14889 data.rule_len_r = tmpi;
14890 }
14891 }
14892 else if (attack_mode == ATTACK_MODE_BF)
14893 {
14894 char *mask = NULL;
14895
14896 maskcnt = 0;
14897
14898 if (benchmark == 0)
14899 {
14900 mask = myargv[optind + 1];
14901
14902 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14903
14904 if ((optind + 2) <= myargc)
14905 {
14906 struct stat file_stat;
14907
14908 if (stat (mask, &file_stat) == -1)
14909 {
14910 maskcnt = 1;
14911
14912 masks[maskcnt - 1] = mystrdup (mask);
14913 }
14914 else
14915 {
14916 int wls_left = myargc - (optind + 1);
14917
14918 uint masks_avail = INCR_MASKS;
14919
14920 for (int i = 0; i < wls_left; i++)
14921 {
14922 if (i != 0)
14923 {
14924 mask = myargv[optind + 1 + i];
14925
14926 if (stat (mask, &file_stat) == -1)
14927 {
14928 log_error ("ERROR: %s: %s", mask, strerror (errno));
14929
14930 return (-1);
14931 }
14932 }
14933
14934 uint is_file = S_ISREG (file_stat.st_mode);
14935
14936 if (is_file == 1)
14937 {
14938 FILE *mask_fp;
14939
14940 if ((mask_fp = fopen (mask, "r")) == NULL)
14941 {
14942 log_error ("ERROR: %s: %s", mask, strerror (errno));
14943
14944 return (-1);
14945 }
14946
14947 char line_buf[BUFSIZ] = { 0 };
14948
14949 while (!feof (mask_fp))
14950 {
14951 memset (line_buf, 0, BUFSIZ);
14952
14953 int line_len = fgetl (mask_fp, line_buf);
14954
14955 if (line_len == 0) continue;
14956
14957 if (line_buf[0] == '#') continue;
14958
14959 if (masks_avail == maskcnt)
14960 {
14961 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14962
14963 masks_avail += INCR_MASKS;
14964 }
14965
14966 masks[maskcnt] = mystrdup (line_buf);
14967
14968 maskcnt++;
14969 }
14970
14971 fclose (mask_fp);
14972 }
14973 else
14974 {
14975 log_error ("ERROR: %s: unsupported file-type", mask);
14976
14977 return (-1);
14978 }
14979 }
14980
14981 mask_from_file = 1;
14982 }
14983 }
14984 else
14985 {
14986 custom_charset_1 = (char *) "?l?d?u";
14987 custom_charset_2 = (char *) "?l?d";
14988 custom_charset_3 = (char *) "?l?d*!$@_";
14989
14990 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14991 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14992 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14993
14994 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14995
14996 wordlist_mode = WL_MODE_MASK;
14997
14998 data.wordlist_mode = wordlist_mode;
14999
15000 increment = 1;
15001
15002 maskcnt = 1;
15003 }
15004 }
15005 else
15006 {
15007 /**
15008 * generate full masks and charsets
15009 */
15010
15011 masks = (char **) mymalloc (sizeof (char *));
15012
15013 switch (hash_mode)
15014 {
15015 case 1731: pw_min = 5;
15016 pw_max = 5;
15017 mask = mystrdup ("?b?b?b?b?b");
15018 break;
15019 case 12500: pw_min = 5;
15020 pw_max = 5;
15021 mask = mystrdup ("?b?b?b?b?b");
15022 break;
15023 default: pw_min = 7;
15024 pw_max = 7;
15025 mask = mystrdup ("?b?b?b?b?b?b?b");
15026 break;
15027 }
15028
15029 maskcnt = 1;
15030
15031 masks[maskcnt - 1] = mystrdup (mask);
15032
15033 wordlist_mode = WL_MODE_MASK;
15034
15035 data.wordlist_mode = wordlist_mode;
15036
15037 increment = 1;
15038 }
15039
15040 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15041
15042 if (increment)
15043 {
15044 if (increment_min > pw_min) pw_min = increment_min;
15045
15046 if (increment_max < pw_max) pw_max = increment_max;
15047 }
15048 }
15049 else if (attack_mode == ATTACK_MODE_HYBRID1)
15050 {
15051 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15052
15053 // display
15054
15055 char *mask = myargv[myargc - 1];
15056
15057 maskcnt = 0;
15058
15059 masks = (char **) mymalloc (1 * sizeof (char *));
15060
15061 // mod
15062
15063 struct stat file_stat;
15064
15065 if (stat (mask, &file_stat) == -1)
15066 {
15067 maskcnt = 1;
15068
15069 masks[maskcnt - 1] = mystrdup (mask);
15070 }
15071 else
15072 {
15073 uint is_file = S_ISREG (file_stat.st_mode);
15074
15075 if (is_file == 1)
15076 {
15077 FILE *mask_fp;
15078
15079 if ((mask_fp = fopen (mask, "r")) == NULL)
15080 {
15081 log_error ("ERROR: %s: %s", mask, strerror (errno));
15082
15083 return (-1);
15084 }
15085
15086 char line_buf[BUFSIZ] = { 0 };
15087
15088 uint masks_avail = 1;
15089
15090 while (!feof (mask_fp))
15091 {
15092 memset (line_buf, 0, BUFSIZ);
15093
15094 int line_len = fgetl (mask_fp, line_buf);
15095
15096 if (line_len == 0) continue;
15097
15098 if (line_buf[0] == '#') continue;
15099
15100 if (masks_avail == maskcnt)
15101 {
15102 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15103
15104 masks_avail += INCR_MASKS;
15105 }
15106
15107 masks[maskcnt] = mystrdup (line_buf);
15108
15109 maskcnt++;
15110 }
15111
15112 fclose (mask_fp);
15113
15114 mask_from_file = 1;
15115 }
15116 else
15117 {
15118 maskcnt = 1;
15119
15120 masks[maskcnt - 1] = mystrdup (mask);
15121 }
15122 }
15123
15124 // base
15125
15126 int wls_left = myargc - (optind + 2);
15127
15128 for (int i = 0; i < wls_left; i++)
15129 {
15130 char *filename = myargv[optind + 1 + i];
15131
15132 struct stat file_stat;
15133
15134 if (stat (filename, &file_stat) == -1)
15135 {
15136 log_error ("ERROR: %s: %s", filename, strerror (errno));
15137
15138 return (-1);
15139 }
15140
15141 uint is_dir = S_ISDIR (file_stat.st_mode);
15142
15143 if (is_dir == 0)
15144 {
15145 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15146
15147 dictcnt++;
15148
15149 dictfiles[dictcnt - 1] = filename;
15150 }
15151 else
15152 {
15153 // do not allow --keyspace w/ a directory
15154
15155 if (keyspace == 1)
15156 {
15157 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15158
15159 return (-1);
15160 }
15161
15162 char **dictionary_files = NULL;
15163
15164 dictionary_files = scan_directory (filename);
15165
15166 if (dictionary_files != NULL)
15167 {
15168 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15169
15170 for (int d = 0; dictionary_files[d] != NULL; d++)
15171 {
15172 char *l1_filename = dictionary_files[d];
15173
15174 struct stat l1_stat;
15175
15176 if (stat (l1_filename, &l1_stat) == -1)
15177 {
15178 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15179
15180 return (-1);
15181 }
15182
15183 if (S_ISREG (l1_stat.st_mode))
15184 {
15185 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15186
15187 dictcnt++;
15188
15189 dictfiles[dictcnt - 1] = strdup (l1_filename);
15190 }
15191 }
15192 }
15193
15194 local_free (dictionary_files);
15195 }
15196 }
15197
15198 if (dictcnt < 1)
15199 {
15200 log_error ("ERROR: No usable dictionary file found.");
15201
15202 return (-1);
15203 }
15204
15205 if (increment)
15206 {
15207 maskcnt = 0;
15208
15209 uint mask_min = increment_min; // we can't reject smaller masks here
15210 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15211
15212 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15213 {
15214 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15215
15216 if (cur_mask == NULL) break;
15217
15218 masks[maskcnt] = cur_mask;
15219
15220 maskcnt++;
15221
15222 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15223 }
15224 }
15225 }
15226 else if (attack_mode == ATTACK_MODE_HYBRID2)
15227 {
15228 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15229
15230 // display
15231
15232 char *mask = myargv[optind + 1 + 0];
15233
15234 maskcnt = 0;
15235
15236 masks = (char **) mymalloc (1 * sizeof (char *));
15237
15238 // mod
15239
15240 struct stat file_stat;
15241
15242 if (stat (mask, &file_stat) == -1)
15243 {
15244 maskcnt = 1;
15245
15246 masks[maskcnt - 1] = mystrdup (mask);
15247 }
15248 else
15249 {
15250 uint is_file = S_ISREG (file_stat.st_mode);
15251
15252 if (is_file == 1)
15253 {
15254 FILE *mask_fp;
15255
15256 if ((mask_fp = fopen (mask, "r")) == NULL)
15257 {
15258 log_error ("ERROR: %s: %s", mask, strerror (errno));
15259
15260 return (-1);
15261 }
15262
15263 char line_buf[BUFSIZ] = { 0 };
15264
15265 uint masks_avail = 1;
15266
15267 while (!feof (mask_fp))
15268 {
15269 memset (line_buf, 0, BUFSIZ);
15270
15271 int line_len = fgetl (mask_fp, line_buf);
15272
15273 if (line_len == 0) continue;
15274
15275 if (line_buf[0] == '#') continue;
15276
15277 if (masks_avail == maskcnt)
15278 {
15279 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15280
15281 masks_avail += INCR_MASKS;
15282 }
15283
15284 masks[maskcnt] = mystrdup (line_buf);
15285
15286 maskcnt++;
15287 }
15288
15289 fclose (mask_fp);
15290
15291 mask_from_file = 1;
15292 }
15293 else
15294 {
15295 maskcnt = 1;
15296
15297 masks[maskcnt - 1] = mystrdup (mask);
15298 }
15299 }
15300
15301 // base
15302
15303 int wls_left = myargc - (optind + 2);
15304
15305 for (int i = 0; i < wls_left; i++)
15306 {
15307 char *filename = myargv[optind + 2 + i];
15308
15309 struct stat file_stat;
15310
15311 if (stat (filename, &file_stat) == -1)
15312 {
15313 log_error ("ERROR: %s: %s", filename, strerror (errno));
15314
15315 return (-1);
15316 }
15317
15318 uint is_dir = S_ISDIR (file_stat.st_mode);
15319
15320 if (is_dir == 0)
15321 {
15322 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15323
15324 dictcnt++;
15325
15326 dictfiles[dictcnt - 1] = filename;
15327 }
15328 else
15329 {
15330 // do not allow --keyspace w/ a directory
15331
15332 if (keyspace == 1)
15333 {
15334 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15335
15336 return (-1);
15337 }
15338
15339 char **dictionary_files = NULL;
15340
15341 dictionary_files = scan_directory (filename);
15342
15343 if (dictionary_files != NULL)
15344 {
15345 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15346
15347 for (int d = 0; dictionary_files[d] != NULL; d++)
15348 {
15349 char *l1_filename = dictionary_files[d];
15350
15351 struct stat l1_stat;
15352
15353 if (stat (l1_filename, &l1_stat) == -1)
15354 {
15355 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15356
15357 return (-1);
15358 }
15359
15360 if (S_ISREG (l1_stat.st_mode))
15361 {
15362 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15363
15364 dictcnt++;
15365
15366 dictfiles[dictcnt - 1] = strdup (l1_filename);
15367 }
15368 }
15369 }
15370
15371 local_free (dictionary_files);
15372 }
15373 }
15374
15375 if (dictcnt < 1)
15376 {
15377 log_error ("ERROR: No usable dictionary file found.");
15378
15379 return (-1);
15380 }
15381
15382 if (increment)
15383 {
15384 maskcnt = 0;
15385
15386 uint mask_min = increment_min; // we can't reject smaller masks here
15387 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15388
15389 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15390 {
15391 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15392
15393 if (cur_mask == NULL) break;
15394
15395 masks[maskcnt] = cur_mask;
15396
15397 maskcnt++;
15398
15399 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15400 }
15401 }
15402 }
15403
15404 data.pw_min = pw_min;
15405 data.pw_max = pw_max;
15406
15407 /**
15408 * weak hash check
15409 */
15410
15411 if (weak_hash_threshold >= salts_cnt)
15412 {
15413 hc_device_param_t *device_param = NULL;
15414
15415 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15416 {
15417 device_param = &data.devices_param[device_id];
15418
15419 if (device_param->skipped) continue;
15420
15421 break;
15422 }
15423
15424 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15425
15426 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15427 {
15428 weak_hash_check (device_param, salt_pos);
15429 }
15430 }
15431
15432 // Display hack, guarantee that there is at least one \r before real start
15433
15434 if (data.quiet == 0) log_info_nn ("");
15435
15436 /**
15437 * status and monitor threads
15438 */
15439
15440 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15441
15442 hc_thread_t i_thread = 0;
15443
15444 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15445 {
15446 hc_thread_create (i_thread, thread_keypress, &benchmark);
15447 }
15448
15449 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15450
15451 uint ni_threads_cnt = 0;
15452
15453 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15454
15455 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15456
15457 ni_threads_cnt++;
15458
15459 /**
15460 * Outfile remove
15461 */
15462
15463 if (keyspace == 0)
15464 {
15465 if (outfile_check_timer != 0)
15466 {
15467 if (data.outfile_check_directory != NULL)
15468 {
15469 if ((hash_mode != 5200) &&
15470 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15471 (hash_mode != 9000))
15472 {
15473 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15474
15475 ni_threads_cnt++;
15476 }
15477 else
15478 {
15479 outfile_check_timer = 0;
15480 }
15481 }
15482 else
15483 {
15484 outfile_check_timer = 0;
15485 }
15486 }
15487 }
15488
15489 /**
15490 * Inform the user if we got some hashes remove because of the pot file remove feature
15491 */
15492
15493 if (data.quiet == 0)
15494 {
15495 if (potfile_remove_cracks > 0)
15496 {
15497 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15498 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15499 }
15500 }
15501
15502 data.outfile_check_timer = outfile_check_timer;
15503
15504 /**
15505 * main loop
15506 */
15507
15508 char **induction_dictionaries = NULL;
15509
15510 int induction_dictionaries_cnt = 0;
15511
15512 hcstat_table_t *root_table_buf = NULL;
15513 hcstat_table_t *markov_table_buf = NULL;
15514
15515 uint initial_restore_done = 0;
15516
15517 data.maskcnt = maskcnt;
15518
15519 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15520 {
15521 if (data.devices_status == STATUS_CRACKED) break;
15522
15523 data.devices_status = STATUS_INIT;
15524
15525 if (maskpos > rd->maskpos)
15526 {
15527 rd->dictpos = 0;
15528 }
15529
15530 rd->maskpos = maskpos;
15531 data.maskpos = maskpos;
15532
15533 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15534 {
15535 char *mask = masks[maskpos];
15536
15537 if (mask_from_file == 1)
15538 {
15539 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15540
15541 char *str_ptr;
15542 uint str_pos;
15543
15544 uint mask_offset = 0;
15545
15546 uint separator_cnt;
15547
15548 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15549 {
15550 str_ptr = strstr (mask + mask_offset, ",");
15551
15552 if (str_ptr == NULL) break;
15553
15554 str_pos = str_ptr - mask;
15555
15556 // escaped separator, i.e. "\,"
15557
15558 if (str_pos > 0)
15559 {
15560 if (mask[str_pos - 1] == '\\')
15561 {
15562 separator_cnt --;
15563
15564 mask_offset = str_pos + 1;
15565
15566 continue;
15567 }
15568 }
15569
15570 // reset the offset
15571
15572 mask_offset = 0;
15573
15574 mask[str_pos] = '\0';
15575
15576 switch (separator_cnt)
15577 {
15578 case 0:
15579 mp_reset_usr (mp_usr, 0);
15580
15581 custom_charset_1 = mask;
15582 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15583 break;
15584
15585 case 1:
15586 mp_reset_usr (mp_usr, 1);
15587
15588 custom_charset_2 = mask;
15589 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15590 break;
15591
15592 case 2:
15593 mp_reset_usr (mp_usr, 2);
15594
15595 custom_charset_3 = mask;
15596 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15597 break;
15598
15599 case 3:
15600 mp_reset_usr (mp_usr, 3);
15601
15602 custom_charset_4 = mask;
15603 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15604 break;
15605 }
15606
15607 mask = mask + str_pos + 1;
15608 }
15609 }
15610
15611 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15612 {
15613 if (maskpos > 0)
15614 {
15615 local_free (css_buf);
15616 local_free (data.root_css_buf);
15617 local_free (data.markov_css_buf);
15618
15619 local_free (masks[maskpos - 1]);
15620 }
15621
15622 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15623
15624 data.mask = mask;
15625 data.css_cnt = css_cnt;
15626 data.css_buf = css_buf;
15627
15628 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15629
15630 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15631
15632 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15633 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15634
15635 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15636
15637 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15638
15639 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15640 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15641
15642 data.root_css_buf = root_css_buf;
15643 data.markov_css_buf = markov_css_buf;
15644
15645 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15646
15647 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15648
15649 local_free (root_table_buf);
15650 local_free (markov_table_buf);
15651
15652 // args
15653
15654 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15655 {
15656 hc_device_param_t *device_param = &data.devices_param[device_id];
15657
15658 if (device_param->skipped) continue;
15659
15660 device_param->kernel_params_mp[0] = &device_param->d_combs;
15661 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15662 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15663
15664 device_param->kernel_params_mp_buf64[3] = 0;
15665 device_param->kernel_params_mp_buf32[4] = css_cnt;
15666 device_param->kernel_params_mp_buf32[5] = 0;
15667 device_param->kernel_params_mp_buf32[6] = 0;
15668 device_param->kernel_params_mp_buf32[7] = 0;
15669
15670 if (attack_mode == ATTACK_MODE_HYBRID1)
15671 {
15672 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15673 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15674 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15675 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15676 }
15677 else if (attack_mode == ATTACK_MODE_HYBRID2)
15678 {
15679 device_param->kernel_params_mp_buf32[5] = 0;
15680 device_param->kernel_params_mp_buf32[6] = 0;
15681 device_param->kernel_params_mp_buf32[7] = 0;
15682 }
15683
15684 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]);
15685 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]);
15686 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]);
15687
15688 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);
15689 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);
15690 }
15691 }
15692 else if (attack_mode == ATTACK_MODE_BF)
15693 {
15694 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15695
15696 if (increment)
15697 {
15698 for (uint i = 0; i < dictcnt; i++)
15699 {
15700 local_free (dictfiles[i]);
15701 }
15702
15703 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15704 {
15705 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15706
15707 if (l1_filename == NULL) break;
15708
15709 dictcnt++;
15710
15711 dictfiles[dictcnt - 1] = l1_filename;
15712 }
15713 }
15714 else
15715 {
15716 dictcnt++;
15717
15718 dictfiles[dictcnt - 1] = mask;
15719 }
15720
15721 if (dictcnt == 0)
15722 {
15723 log_error ("ERROR: Mask is too small");
15724
15725 return (-1);
15726 }
15727 }
15728 }
15729
15730 free (induction_dictionaries);
15731
15732 // induction_dictionaries_cnt = 0; // implied
15733
15734 if (attack_mode != ATTACK_MODE_BF)
15735 {
15736 if (keyspace == 0)
15737 {
15738 induction_dictionaries = scan_directory (induction_directory);
15739
15740 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15741 }
15742 }
15743
15744 if (induction_dictionaries_cnt)
15745 {
15746 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15747 }
15748
15749 /**
15750 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15751 */
15752 if (keyspace == 1)
15753 {
15754 if ((maskcnt > 1) || (dictcnt > 1))
15755 {
15756 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15757
15758 return (-1);
15759 }
15760 }
15761
15762 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15763 {
15764 char *subid = logfile_generate_subid ();
15765
15766 data.subid = subid;
15767
15768 logfile_sub_msg ("START");
15769
15770 data.devices_status = STATUS_INIT;
15771
15772 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15773 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15774 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15775
15776 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15777
15778 data.cpt_pos = 0;
15779
15780 data.cpt_start = time (NULL);
15781
15782 data.cpt_total = 0;
15783
15784 if (data.restore == 0)
15785 {
15786 rd->words_cur = skip;
15787
15788 skip = 0;
15789
15790 data.skip = 0;
15791 }
15792
15793 data.ms_paused = 0;
15794
15795 data.words_cur = rd->words_cur;
15796
15797 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15798 {
15799 hc_device_param_t *device_param = &data.devices_param[device_id];
15800
15801 if (device_param->skipped) continue;
15802
15803 device_param->speed_pos = 0;
15804
15805 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15806 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15807 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15808
15809 device_param->exec_pos = 0;
15810
15811 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15812
15813 device_param->kernel_power = device_param->kernel_power_user;
15814
15815 device_param->outerloop_pos = 0;
15816 device_param->outerloop_left = 0;
15817 device_param->innerloop_pos = 0;
15818 device_param->innerloop_left = 0;
15819
15820 // some more resets:
15821
15822 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15823
15824 device_param->pws_cnt = 0;
15825
15826 device_param->words_off = 0;
15827 device_param->words_done = 0;
15828 }
15829
15830 data.kernel_power_div = 0;
15831
15832 // figure out some workload
15833
15834 if (attack_mode == ATTACK_MODE_STRAIGHT)
15835 {
15836 if (data.wordlist_mode == WL_MODE_FILE)
15837 {
15838 char *dictfile = NULL;
15839
15840 if (induction_dictionaries_cnt)
15841 {
15842 dictfile = induction_dictionaries[0];
15843 }
15844 else
15845 {
15846 dictfile = dictfiles[dictpos];
15847 }
15848
15849 data.dictfile = dictfile;
15850
15851 logfile_sub_string (dictfile);
15852
15853 for (uint i = 0; i < rp_files_cnt; i++)
15854 {
15855 logfile_sub_var_string ("rulefile", rp_files[i]);
15856 }
15857
15858 FILE *fd2 = fopen (dictfile, "rb");
15859
15860 if (fd2 == NULL)
15861 {
15862 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15863
15864 return (-1);
15865 }
15866
15867 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15868
15869 fclose (fd2);
15870
15871 if (data.words_cnt == 0)
15872 {
15873 if (data.devices_status == STATUS_CRACKED) break;
15874 if (data.devices_status == STATUS_ABORTED) break;
15875
15876 dictpos++;
15877
15878 continue;
15879 }
15880 }
15881 }
15882 else if (attack_mode == ATTACK_MODE_COMBI)
15883 {
15884 char *dictfile = data.dictfile;
15885 char *dictfile2 = data.dictfile2;
15886
15887 logfile_sub_string (dictfile);
15888 logfile_sub_string (dictfile2);
15889
15890 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15891 {
15892 FILE *fd2 = fopen (dictfile, "rb");
15893
15894 if (fd2 == NULL)
15895 {
15896 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15897
15898 return (-1);
15899 }
15900
15901 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15902
15903 fclose (fd2);
15904 }
15905 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15906 {
15907 FILE *fd2 = fopen (dictfile2, "rb");
15908
15909 if (fd2 == NULL)
15910 {
15911 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15912
15913 return (-1);
15914 }
15915
15916 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15917
15918 fclose (fd2);
15919 }
15920
15921 if (data.words_cnt == 0)
15922 {
15923 if (data.devices_status == STATUS_CRACKED) break;
15924 if (data.devices_status == STATUS_ABORTED) break;
15925
15926 dictpos++;
15927
15928 continue;
15929 }
15930 }
15931 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15932 {
15933 char *dictfile = NULL;
15934
15935 if (induction_dictionaries_cnt)
15936 {
15937 dictfile = induction_dictionaries[0];
15938 }
15939 else
15940 {
15941 dictfile = dictfiles[dictpos];
15942 }
15943
15944 data.dictfile = dictfile;
15945
15946 char *mask = data.mask;
15947
15948 logfile_sub_string (dictfile);
15949 logfile_sub_string (mask);
15950
15951 FILE *fd2 = fopen (dictfile, "rb");
15952
15953 if (fd2 == NULL)
15954 {
15955 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15956
15957 return (-1);
15958 }
15959
15960 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15961
15962 fclose (fd2);
15963
15964 if (data.words_cnt == 0)
15965 {
15966 if (data.devices_status == STATUS_CRACKED) break;
15967 if (data.devices_status == STATUS_ABORTED) break;
15968
15969 dictpos++;
15970
15971 continue;
15972 }
15973 }
15974 else if (attack_mode == ATTACK_MODE_BF)
15975 {
15976 local_free (css_buf);
15977 local_free (data.root_css_buf);
15978 local_free (data.markov_css_buf);
15979
15980 char *mask = dictfiles[dictpos];
15981
15982 logfile_sub_string (mask);
15983
15984 // base
15985
15986 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15987
15988 if (opts_type & OPTS_TYPE_PT_UNICODE)
15989 {
15990 uint css_cnt_unicode = css_cnt * 2;
15991
15992 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15993
15994 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15995 {
15996 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15997
15998 css_buf_unicode[j + 1].cs_buf[0] = 0;
15999 css_buf_unicode[j + 1].cs_len = 1;
16000 }
16001
16002 free (css_buf);
16003
16004 css_buf = css_buf_unicode;
16005 css_cnt = css_cnt_unicode;
16006 }
16007
16008 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16009
16010 uint mask_min = pw_min;
16011 uint mask_max = pw_max;
16012
16013 if (opts_type & OPTS_TYPE_PT_UNICODE)
16014 {
16015 mask_min *= 2;
16016 mask_max *= 2;
16017 }
16018
16019 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16020 {
16021 if (css_cnt < mask_min)
16022 {
16023 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16024 }
16025
16026 if (css_cnt > mask_max)
16027 {
16028 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16029 }
16030
16031 // skip to next mask
16032
16033 dictpos++;
16034
16035 rd->dictpos = dictpos;
16036
16037 logfile_sub_msg ("STOP");
16038
16039 continue;
16040 }
16041
16042 uint save_css_cnt = css_cnt;
16043
16044 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16045 {
16046 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16047 {
16048 uint salt_len = (uint) data.salts_buf[0].salt_len;
16049 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16050
16051 uint css_cnt_salt = css_cnt + salt_len;
16052
16053 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16054
16055 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16056
16057 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16058 {
16059 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16060 css_buf_salt[j].cs_len = 1;
16061 }
16062
16063 free (css_buf);
16064
16065 css_buf = css_buf_salt;
16066 css_cnt = css_cnt_salt;
16067 }
16068 }
16069
16070 data.mask = mask;
16071 data.css_cnt = css_cnt;
16072 data.css_buf = css_buf;
16073
16074 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16075
16076 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16077
16078 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16079
16080 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16081 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16082
16083 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16084
16085 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16086
16087 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16088 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16089
16090 data.root_css_buf = root_css_buf;
16091 data.markov_css_buf = markov_css_buf;
16092
16093 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16094
16095 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16096
16097 local_free (root_table_buf);
16098 local_free (markov_table_buf);
16099
16100 // copy + args
16101
16102 uint css_cnt_l = css_cnt;
16103 uint css_cnt_r;
16104
16105 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16106 {
16107 if (save_css_cnt < 6)
16108 {
16109 css_cnt_r = 1;
16110 }
16111 else if (save_css_cnt == 6)
16112 {
16113 css_cnt_r = 2;
16114 }
16115 else
16116 {
16117 if (opts_type & OPTS_TYPE_PT_UNICODE)
16118 {
16119 if (save_css_cnt == 8 || save_css_cnt == 10)
16120 {
16121 css_cnt_r = 2;
16122 }
16123 else
16124 {
16125 css_cnt_r = 4;
16126 }
16127 }
16128 else
16129 {
16130 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16131 {
16132 css_cnt_r = 3;
16133 }
16134 else
16135 {
16136 css_cnt_r = 4;
16137 }
16138 }
16139 }
16140 }
16141 else
16142 {
16143 css_cnt_r = 1;
16144
16145 /* unfinished code?
16146 int sum = css_buf[css_cnt_r - 1].cs_len;
16147
16148 for (uint i = 1; i < 4 && i < css_cnt; i++)
16149 {
16150 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16151
16152 css_cnt_r++;
16153
16154 sum *= css_buf[css_cnt_r - 1].cs_len;
16155 }
16156 */
16157 }
16158
16159 css_cnt_l -= css_cnt_r;
16160
16161 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16162
16163 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16164 {
16165 hc_device_param_t *device_param = &data.devices_param[device_id];
16166
16167 if (device_param->skipped) continue;
16168
16169 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16170 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16171 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16172
16173 device_param->kernel_params_mp_l_buf64[3] = 0;
16174 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16175 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16176 device_param->kernel_params_mp_l_buf32[6] = 0;
16177 device_param->kernel_params_mp_l_buf32[7] = 0;
16178 device_param->kernel_params_mp_l_buf32[8] = 0;
16179
16180 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16181 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16182 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16183 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16184
16185 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16186 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16187 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16188
16189 device_param->kernel_params_mp_r_buf64[3] = 0;
16190 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16191 device_param->kernel_params_mp_r_buf32[5] = 0;
16192 device_param->kernel_params_mp_r_buf32[6] = 0;
16193 device_param->kernel_params_mp_r_buf32[7] = 0;
16194
16195 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]);
16196 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]);
16197 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]);
16198
16199 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]);
16200 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]);
16201 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]);
16202
16203 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);
16204 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);
16205 }
16206 }
16207
16208 u64 words_base = data.words_cnt;
16209
16210 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16211 {
16212 if (data.kernel_rules_cnt)
16213 {
16214 words_base /= data.kernel_rules_cnt;
16215 }
16216 }
16217 else if (data.attack_kern == ATTACK_KERN_COMBI)
16218 {
16219 if (data.combs_cnt)
16220 {
16221 words_base /= data.combs_cnt;
16222 }
16223 }
16224 else if (data.attack_kern == ATTACK_KERN_BF)
16225 {
16226 if (data.bfs_cnt)
16227 {
16228 words_base /= data.bfs_cnt;
16229 }
16230 }
16231
16232 data.words_base = words_base;
16233
16234 if (keyspace == 1)
16235 {
16236 log_info ("%llu", (unsigned long long int) words_base);
16237
16238 return (0);
16239 }
16240
16241 if (data.words_cur > data.words_base)
16242 {
16243 log_error ("ERROR: restore value greater keyspace");
16244
16245 return (-1);
16246 }
16247
16248 if (data.words_cur)
16249 {
16250 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16251 {
16252 for (uint i = 0; i < data.salts_cnt; i++)
16253 {
16254 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16255 }
16256 }
16257 else if (data.attack_kern == ATTACK_KERN_COMBI)
16258 {
16259 for (uint i = 0; i < data.salts_cnt; i++)
16260 {
16261 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16262 }
16263 }
16264 else if (data.attack_kern == ATTACK_KERN_BF)
16265 {
16266 for (uint i = 0; i < data.salts_cnt; i++)
16267 {
16268 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16269 }
16270 }
16271 }
16272
16273 /*
16274 * Inform user about possible slow speeds
16275 */
16276
16277 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16278 {
16279 if (data.words_base < kernel_power_all)
16280 {
16281 if (quiet == 0)
16282 {
16283 log_info ("");
16284 log_info ("ATTENTION!");
16285 log_info (" The wordlist or mask you are using is too small.");
16286 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16287 log_info (" The cracking speed will drop.");
16288 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16289 log_info ("");
16290 }
16291 }
16292 }
16293
16294 /*
16295 * Update loopback file
16296 */
16297
16298 if (loopback == 1)
16299 {
16300 time_t now;
16301
16302 time (&now);
16303
16304 uint random_num = get_random_num (0, 9999);
16305
16306 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16307
16308 data.loopback_file = loopback_file;
16309 }
16310
16311 /*
16312 * Update dictionary statistic
16313 */
16314
16315 if (keyspace == 0)
16316 {
16317 dictstat_fp = fopen (dictstat, "wb");
16318
16319 if (dictstat_fp)
16320 {
16321 lock_file (dictstat_fp);
16322
16323 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16324
16325 fclose (dictstat_fp);
16326 }
16327 }
16328
16329 data.devices_status = STATUS_RUNNING;
16330
16331 if (initial_restore_done == 0)
16332 {
16333 if (data.restore_disable == 0) cycle_restore ();
16334
16335 initial_restore_done = 1;
16336 }
16337
16338 hc_timer_set (&data.timer_running);
16339
16340 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16341 {
16342 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16343 {
16344 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16345 if (quiet == 0) fflush (stdout);
16346 }
16347 }
16348 else if (wordlist_mode == WL_MODE_STDIN)
16349 {
16350 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16351 if (data.quiet == 0) log_info ("");
16352 }
16353
16354 time_t runtime_start;
16355
16356 time (&runtime_start);
16357
16358 data.runtime_start = runtime_start;
16359
16360 /**
16361 * create cracker threads
16362 */
16363
16364 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16365
16366 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16367 {
16368 hc_device_param_t *device_param = &devices_param[device_id];
16369
16370 if (wordlist_mode == WL_MODE_STDIN)
16371 {
16372 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16373 }
16374 else
16375 {
16376 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16377 }
16378 }
16379
16380 // wait for crack threads to exit
16381
16382 hc_thread_wait (data.devices_cnt, c_threads);
16383
16384 local_free (c_threads);
16385
16386 data.restore = 0;
16387
16388 // finalize task
16389
16390 logfile_sub_var_uint ("status-after-work", data.devices_status);
16391
16392 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16393
16394 if (data.devices_status == STATUS_CRACKED) break;
16395 if (data.devices_status == STATUS_ABORTED) break;
16396
16397 if (data.devices_status == STATUS_BYPASS)
16398 {
16399 data.devices_status = STATUS_RUNNING;
16400 }
16401
16402 if (induction_dictionaries_cnt)
16403 {
16404 unlink (induction_dictionaries[0]);
16405 }
16406
16407 free (induction_dictionaries);
16408
16409 if (attack_mode != ATTACK_MODE_BF)
16410 {
16411 induction_dictionaries = scan_directory (induction_directory);
16412
16413 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16414 }
16415
16416 if (benchmark == 0)
16417 {
16418 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16419 {
16420 if (quiet == 0) clear_prompt ();
16421
16422 if (quiet == 0) log_info ("");
16423
16424 if (status == 1)
16425 {
16426 status_display ();
16427 }
16428 else
16429 {
16430 if (quiet == 0) status_display ();
16431 }
16432
16433 if (quiet == 0) log_info ("");
16434 }
16435 }
16436
16437 if (attack_mode == ATTACK_MODE_BF)
16438 {
16439 dictpos++;
16440
16441 rd->dictpos = dictpos;
16442 }
16443 else
16444 {
16445 if (induction_dictionaries_cnt)
16446 {
16447 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16448 }
16449 else
16450 {
16451 dictpos++;
16452
16453 rd->dictpos = dictpos;
16454 }
16455 }
16456
16457 time_t runtime_stop;
16458
16459 time (&runtime_stop);
16460
16461 data.runtime_stop = runtime_stop;
16462
16463 logfile_sub_uint (runtime_start);
16464 logfile_sub_uint (runtime_stop);
16465
16466 logfile_sub_msg ("STOP");
16467
16468 global_free (subid);
16469 }
16470
16471 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16472
16473 if (data.devices_status == STATUS_CRACKED) break;
16474 if (data.devices_status == STATUS_ABORTED) break;
16475 if (data.devices_status == STATUS_QUIT) break;
16476
16477 if (data.devices_status == STATUS_BYPASS)
16478 {
16479 data.devices_status = STATUS_RUNNING;
16480 }
16481 }
16482
16483 // 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
16484
16485 if (attack_mode == ATTACK_MODE_STRAIGHT)
16486 {
16487 if (data.wordlist_mode == WL_MODE_FILE)
16488 {
16489 if (data.dictfile == NULL)
16490 {
16491 if (dictfiles != NULL)
16492 {
16493 data.dictfile = dictfiles[0];
16494
16495 hc_timer_set (&data.timer_running);
16496 }
16497 }
16498 }
16499 }
16500 // NOTE: combi is okay because it is already set beforehand
16501 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16502 {
16503 if (data.dictfile == NULL)
16504 {
16505 if (dictfiles != NULL)
16506 {
16507 hc_timer_set (&data.timer_running);
16508
16509 data.dictfile = dictfiles[0];
16510 }
16511 }
16512 }
16513 else if (attack_mode == ATTACK_MODE_BF)
16514 {
16515 if (data.mask == NULL)
16516 {
16517 hc_timer_set (&data.timer_running);
16518
16519 data.mask = masks[0];
16520 }
16521 }
16522
16523 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16524 {
16525 data.devices_status = STATUS_EXHAUSTED;
16526 }
16527
16528 // if cracked / aborted remove last induction dictionary
16529
16530 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16531 {
16532 struct stat induct_stat;
16533
16534 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16535 {
16536 unlink (induction_dictionaries[file_pos]);
16537 }
16538 }
16539
16540 // wait for non-interactive threads
16541
16542 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16543 {
16544 hc_thread_wait (1, &ni_threads[thread_idx]);
16545 }
16546
16547 local_free (ni_threads);
16548
16549 // wait for interactive threads
16550
16551 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16552 {
16553 hc_thread_wait (1, &i_thread);
16554 }
16555
16556 // we dont need restore file anymore
16557 if (data.restore_disable == 0)
16558 {
16559 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16560 {
16561 unlink (eff_restore_file);
16562 unlink (new_restore_file);
16563 }
16564 else
16565 {
16566 cycle_restore ();
16567 }
16568 }
16569
16570 // finally save left hashes
16571
16572 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16573 {
16574 save_hash ();
16575 }
16576
16577 /**
16578 * Clean up
16579 */
16580
16581 if (benchmark == 1)
16582 {
16583 status_benchmark ();
16584
16585 log_info ("");
16586 }
16587 else
16588 {
16589 if (quiet == 0) clear_prompt ();
16590
16591 if (quiet == 0) log_info ("");
16592
16593 if (status == 1)
16594 {
16595 status_display ();
16596 }
16597 else
16598 {
16599 if (quiet == 0) status_display ();
16600 }
16601
16602 if (quiet == 0) log_info ("");
16603 }
16604
16605 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16606 {
16607 hc_device_param_t *device_param = &data.devices_param[device_id];
16608
16609 if (device_param->skipped) continue;
16610
16611 local_free (device_param->result);
16612
16613 local_free (device_param->combs_buf);
16614
16615 local_free (device_param->hooks_buf);
16616
16617 local_free (device_param->device_name);
16618
16619 local_free (device_param->device_name_chksum);
16620
16621 local_free (device_param->device_version);
16622
16623 local_free (device_param->driver_version);
16624
16625 if (device_param->pws_buf) myfree (device_param->pws_buf);
16626 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16627 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16628 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16629 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16630 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16631 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16632 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16633 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16634 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16635 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16636 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16637 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16638 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16639 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16640 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16641 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16642 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16643 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16644 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16645 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16646 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16647 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16648 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16649 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16650 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16651 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16652 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16653 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16654
16655 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16656 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16657 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16658 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16659 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16660 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16661 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16662 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16663 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16664 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16665 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16666
16667 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16668 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16669 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16670
16671 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16672 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16673 }
16674
16675 // reset default fan speed
16676
16677 #ifdef HAVE_HWMON
16678 if (gpu_temp_disable == 0)
16679 {
16680 #ifdef HAVE_ADL
16681 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16682 {
16683 hc_thread_mutex_lock (mux_adl);
16684
16685 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16686 {
16687 hc_device_param_t *device_param = &data.devices_param[device_id];
16688
16689 if (device_param->skipped) continue;
16690
16691 if (data.hm_device[device_id].fan_supported == 1)
16692 {
16693 int fanspeed = temp_retain_fanspeed_value[device_id];
16694
16695 if (fanspeed == -1) continue;
16696
16697 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16698
16699 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16700 }
16701 }
16702
16703 hc_thread_mutex_unlock (mux_adl);
16704 }
16705 #endif // HAVE_ADL
16706 }
16707
16708 #ifdef HAVE_ADL
16709 // reset power tuning
16710
16711 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16712 {
16713 hc_thread_mutex_lock (mux_adl);
16714
16715 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16716 {
16717 hc_device_param_t *device_param = &data.devices_param[device_id];
16718
16719 if (device_param->skipped) continue;
16720
16721 if (data.hm_device[device_id].od_version == 6)
16722 {
16723 // check powertune capabilities first, if not available then skip device
16724
16725 int powertune_supported = 0;
16726
16727 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16728 {
16729 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16730
16731 return (-1);
16732 }
16733
16734 if (powertune_supported != 0)
16735 {
16736 // powercontrol settings
16737
16738 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)
16739 {
16740 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16741
16742 return (-1);
16743 }
16744
16745 // clocks
16746
16747 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16748
16749 performance_state->iNumberOfPerformanceLevels = 2;
16750
16751 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16752 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16753 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16754 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16755
16756 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)
16757 {
16758 log_info ("ERROR: Failed to restore ADL performance state");
16759
16760 return (-1);
16761 }
16762
16763 local_free (performance_state);
16764 }
16765 }
16766 }
16767
16768 hc_thread_mutex_unlock (mux_adl);
16769 }
16770 #endif // HAVE_ADL
16771
16772 if (gpu_temp_disable == 0)
16773 {
16774 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16775 if (data.hm_nv)
16776 {
16777 #if defined(LINUX) && defined(HAVE_NVML)
16778
16779 hm_NVML_nvmlShutdown (data.hm_nv);
16780
16781 nvml_close (data.hm_nv);
16782
16783 #elif defined(WIN) && (HAVE_NVAPI)
16784
16785 hm_NvAPI_Unload (data.hm_nv);
16786
16787 nvapi_close (data.hm_nv);
16788
16789 #endif
16790
16791 data.hm_nv = NULL;
16792 }
16793 #endif
16794
16795 #ifdef HAVE_ADL
16796 if (data.hm_amd)
16797 {
16798 hm_ADL_Main_Control_Destroy (data.hm_amd);
16799
16800 adl_close (data.hm_amd);
16801 data.hm_amd = NULL;
16802 }
16803 #endif
16804 }
16805 #endif // HAVE_HWMON
16806
16807 // free memory
16808
16809 local_free (masks);
16810
16811 local_free (dictstat_base);
16812
16813 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16814 {
16815 pot_t *pot_ptr = &pot[pot_pos];
16816
16817 hash_t *hash = &pot_ptr->hash;
16818
16819 local_free (hash->digest);
16820
16821 if (isSalted)
16822 {
16823 local_free (hash->salt);
16824 }
16825 }
16826
16827 local_free (pot);
16828
16829 local_free (all_kernel_rules_cnt);
16830 local_free (all_kernel_rules_buf);
16831
16832 local_free (wl_data->buf);
16833 local_free (wl_data);
16834
16835 local_free (bitmap_s1_a);
16836 local_free (bitmap_s1_b);
16837 local_free (bitmap_s1_c);
16838 local_free (bitmap_s1_d);
16839 local_free (bitmap_s2_a);
16840 local_free (bitmap_s2_b);
16841 local_free (bitmap_s2_c);
16842 local_free (bitmap_s2_d);
16843
16844 #ifdef HAVE_HWMON
16845 local_free (temp_retain_fanspeed_value);
16846 #ifdef HAVE_ADL
16847 local_free (od_clock_mem_status);
16848 local_free (od_power_control_status);
16849 #endif // ADL
16850 #endif
16851
16852 global_free (devices_param);
16853
16854 global_free (kernel_rules_buf);
16855
16856 global_free (root_css_buf);
16857 global_free (markov_css_buf);
16858
16859 global_free (digests_buf);
16860 global_free (digests_shown);
16861 global_free (digests_shown_tmp);
16862
16863 global_free (salts_buf);
16864 global_free (salts_shown);
16865
16866 global_free (esalts_buf);
16867
16868 global_free (words_progress_done);
16869 global_free (words_progress_rejected);
16870 global_free (words_progress_restored);
16871
16872 if (pot_fp) fclose (pot_fp);
16873
16874 if (data.devices_status == STATUS_QUIT) break;
16875 }
16876
16877 // destroy others mutex
16878
16879 hc_thread_mutex_delete (mux_dispatcher);
16880 hc_thread_mutex_delete (mux_counter);
16881 hc_thread_mutex_delete (mux_display);
16882 hc_thread_mutex_delete (mux_adl);
16883
16884 // free memory
16885
16886 local_free (eff_restore_file);
16887 local_free (new_restore_file);
16888
16889 local_free (rd);
16890
16891 // tuning db
16892
16893 tuning_db_destroy (tuning_db);
16894
16895 // loopback
16896
16897 local_free (loopback_file);
16898
16899 if (loopback == 1) unlink (loopback_file);
16900
16901 // induction directory
16902
16903 if (induction_dir == NULL)
16904 {
16905 if (attack_mode != ATTACK_MODE_BF)
16906 {
16907 if (rmdir (induction_directory) == -1)
16908 {
16909 if (errno == ENOENT)
16910 {
16911 // good, we can ignore
16912 }
16913 else if (errno == ENOTEMPTY)
16914 {
16915 // good, we can ignore
16916 }
16917 else
16918 {
16919 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16920
16921 return (-1);
16922 }
16923 }
16924
16925 local_free (induction_directory);
16926 }
16927 }
16928
16929 // outfile-check directory
16930
16931 if (outfile_check_dir == NULL)
16932 {
16933 if (rmdir (outfile_check_directory) == -1)
16934 {
16935 if (errno == ENOENT)
16936 {
16937 // good, we can ignore
16938 }
16939 else if (errno == ENOTEMPTY)
16940 {
16941 // good, we can ignore
16942 }
16943 else
16944 {
16945 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16946
16947 return (-1);
16948 }
16949 }
16950
16951 local_free (outfile_check_directory);
16952 }
16953
16954 time_t proc_stop;
16955
16956 time (&proc_stop);
16957
16958 logfile_top_uint (proc_start);
16959 logfile_top_uint (proc_stop);
16960
16961 logfile_top_msg ("STOP");
16962
16963 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16964 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16965
16966 if (data.ocl) ocl_close (data.ocl);
16967
16968 if (data.devices_status == STATUS_ABORTED) return 2;
16969 if (data.devices_status == STATUS_QUIT) return 2;
16970 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16971 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16972 if (data.devices_status == STATUS_CRACKED) return 0;
16973
16974 return -1;
16975 }
Hashcat additions to support pwdhash