projects / hashcat.git / blob
? search:


114cb3d3d3f66be5dbe66b378988a94bc1bcc27e
[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 RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
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 HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 136
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 12500,
274 13000,
275 13200,
276 13300,
277 6211,
278 6221,
279 6231,
280 6241,
281 8800,
282 12900,
283 12200,
284 9700,
285 9710,
286 9800,
287 9810,
288 9400,
289 9500,
290 9600,
291 10400,
292 10410,
293 10500,
294 10600,
295 10700,
296 9000,
297 5200,
298 6800,
299 6600,
300 8200,
301 11300,
302 12700,
303 13400,
304 125
305 };
306
307 /**
308 * types
309 */
310
311 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
312
313 /**
314 * globals
315 */
316
317 static unsigned int full01 = 0x01010101;
318 static unsigned int full80 = 0x80808080;
319
320 int SUPPRESS_OUTPUT = 0;
321
322 hc_thread_mutex_t mux_adl;
323 hc_thread_mutex_t mux_counter;
324 hc_thread_mutex_t mux_dispatcher;
325 hc_thread_mutex_t mux_display;
326
327 hc_global_data_t data;
328
329 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
330
331 const char *USAGE_MINI[] =
332 {
333 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
334 "",
335 "Try --help for more help.",
336 NULL
337 };
338
339 const char *USAGE_BIG[] =
340 {
341 "%s, advanced password recovery",
342 "",
343 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
344 "",
345 "=======",
346 "Options",
347 "=======",
348 "",
349 "* General:",
350 "",
351 " -m, --hash-type=NUM Hash-type, see references below",
352 " -a, --attack-mode=NUM Attack-mode, see references below",
353 " -V, --version Print version",
354 " -h, --help Print help",
355 " --quiet Suppress output",
356 "",
357 "* Misc:",
358 "",
359 " --hex-charset Assume charset is given in hex",
360 " --hex-salt Assume salt is given in hex",
361 " --hex-wordlist Assume words in wordlist is given in hex",
362 " --force Ignore warnings",
363 " --status Enable automatic update of the status-screen",
364 " --status-timer=NUM Seconds between status-screen update",
365 " --status-automat Display the status view in a machine readable format",
366 " --loopback Add new plains to induct directory",
367 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
368 "",
369 "* Markov:",
370 "",
371 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
372 " --markov-disable Disables markov-chains, emulates classic brute-force",
373 " --markov-classic Enables classic markov-chains, no per-position enhancement",
374 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
375 "",
376 "* Session:",
377 "",
378 " --runtime=NUM Abort session after NUM seconds of runtime",
379 " --session=STR Define specific session name",
380 " --restore Restore session from --session",
381 " --restore-disable Do not write restore file",
382 "",
383 "* Files:",
384 "",
385 " -o, --outfile=FILE Define outfile for recovered hash",
386 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
387 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
388 " --outfile-check-timer=NUM Seconds between outfile checks",
389 " -p, --separator=CHAR Separator char for hashlists and outfile",
390 " --show Show cracked passwords only",
391 " --left Show un-cracked passwords only",
392 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
393 " --remove Enable remove of hash once it is cracked",
394 " --remove-timer=NUM Update input hash file each NUM seconds",
395 " --potfile-disable Do not write potfile",
396 " --potfile-path Specific path to potfile",
397 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
398 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
399 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
400 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
401 " --logfile-disable Disable the logfile",
402 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
403 "",
404 "* Resources:",
405 "",
406 " -b, --benchmark Run benchmark",
407 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
408 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
409 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
410 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
411 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
412 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
413 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
414 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
415 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
416 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
417 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
418 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
419 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
420 #ifdef HAVE_HWMON
421 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
422 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
423 #ifdef HAVE_ADL
424 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
425 #endif
426 #endif
427 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
428 "",
429 "* Distributed:",
430 "",
431 " -s, --skip=NUM Skip number of words",
432 " -l, --limit=NUM Limit number of words",
433 " --keyspace Show keyspace base:mod values and quit",
434 "",
435 "* Rules:",
436 "",
437 " -j, --rule-left=RULE Single rule applied to each word from left dict",
438 " -k, --rule-right=RULE Single rule applied to each word from right dict",
439 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
440 " -g, --generate-rules=NUM Generate NUM random rules",
441 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
442 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
443 " --generate-rules-seed=NUM Force RNG seed to NUM",
444 "",
445 "* Custom charsets:",
446 "",
447 " -1, --custom-charset1=CS User-defined charsets",
448 " -2, --custom-charset2=CS Example:",
449 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
450 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
451 "",
452 "* Increment:",
453 "",
454 " -i, --increment Enable increment mode",
455 " --increment-min=NUM Start incrementing at NUM",
456 " --increment-max=NUM Stop incrementing at NUM",
457 "",
458 "==========",
459 "References",
460 "==========",
461 "",
462 "* Workload Profile:",
463 "",
464 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
465 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
466 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
467 "",
468 "* OpenCL device-types:",
469 "",
470 " 1 = CPU devices",
471 " 2 = GPU devices",
472 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
473 "",
474 "* Outfile Formats:",
475 "",
476 " 1 = hash[:salt]",
477 " 2 = plain",
478 " 3 = hash[:salt]:plain",
479 " 4 = hex_plain",
480 " 5 = hash[:salt]:hex_plain",
481 " 6 = plain:hex_plain",
482 " 7 = hash[:salt]:plain:hex_plain",
483 " 8 = crackpos",
484 " 9 = hash[:salt]:crackpos",
485 " 10 = plain:crackpos",
486 " 11 = hash[:salt]:plain:crackpos",
487 " 12 = hex_plain:crackpos",
488 " 13 = hash[:salt]:hex_plain:crackpos",
489 " 14 = plain:hex_plain:crackpos",
490 " 15 = hash[:salt]:plain:hex_plain:crackpos",
491 "",
492 "* Debug mode output formats (for hybrid mode only, by using rules):",
493 "",
494 " 1 = save finding rule",
495 " 2 = save original word",
496 " 3 = save original word and finding rule",
497 " 4 = save original word, finding rule and modified plain",
498 "",
499 "* Built-in charsets:",
500 "",
501 " ?l = abcdefghijklmnopqrstuvwxyz",
502 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
503 " ?d = 0123456789",
504 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
505 " ?a = ?l?u?d?s",
506 " ?b = 0x00 - 0xff",
507 "",
508 "* Attack modes:",
509 "",
510 " 0 = Straight",
511 " 1 = Combination",
512 " 3 = Brute-force",
513 " 6 = Hybrid dict + mask",
514 " 7 = Hybrid mask + dict",
515 "",
516 "* Hash types:",
517 "",
518 "[[ Roll-your-own: Raw Hashes ]]",
519 "",
520 " 900 = MD4",
521 " 0 = MD5",
522 " 5100 = Half MD5",
523 " 100 = SHA1",
524 " 10800 = SHA-384",
525 " 1400 = SHA-256",
526 " 1700 = SHA-512",
527 " 5000 = SHA-3(Keccak)",
528 " 10100 = SipHash",
529 " 6000 = RipeMD160",
530 " 6100 = Whirlpool",
531 " 6900 = GOST R 34.11-94",
532 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
533 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
534 "",
535 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
536 "",
537 " 10 = md5($pass.$salt)",
538 " 20 = md5($salt.$pass)",
539 " 30 = md5(unicode($pass).$salt)",
540 " 40 = md5($salt.unicode($pass))",
541 " 3800 = md5($salt.$pass.$salt)",
542 " 3710 = md5($salt.md5($pass))",
543 " 2600 = md5(md5($pass)",
544 " 4300 = md5(strtoupper(md5($pass)))",
545 " 4400 = md5(sha1($pass))",
546 " 110 = sha1($pass.$salt)",
547 " 120 = sha1($salt.$pass)",
548 " 130 = sha1(unicode($pass).$salt)",
549 " 140 = sha1($salt.unicode($pass))",
550 " 4500 = sha1(sha1($pass)",
551 " 4700 = sha1(md5($pass))",
552 " 4900 = sha1($salt.$pass.$salt)",
553 " 1410 = sha256($pass.$salt)",
554 " 1420 = sha256($salt.$pass)",
555 " 1430 = sha256(unicode($pass).$salt)",
556 " 1440 = sha256($salt.unicode($pass))",
557 " 1710 = sha512($pass.$salt)",
558 " 1720 = sha512($salt.$pass)",
559 " 1730 = sha512(unicode($pass).$salt)",
560 " 1740 = sha512($salt.unicode($pass))",
561 "",
562 "[[ Roll-your-own: Authenticated Hashes ]]",
563 "",
564 " 50 = HMAC-MD5 (key = $pass)",
565 " 60 = HMAC-MD5 (key = $salt)",
566 " 150 = HMAC-SHA1 (key = $pass)",
567 " 160 = HMAC-SHA1 (key = $salt)",
568 " 1450 = HMAC-SHA256 (key = $pass)",
569 " 1460 = HMAC-SHA256 (key = $salt)",
570 " 1750 = HMAC-SHA512 (key = $pass)",
571 " 1760 = HMAC-SHA512 (key = $salt)",
572 "",
573 "[[ Generic KDF ]]",
574 "",
575 " 400 = phpass",
576 " 8900 = scrypt",
577 " 11900 = PBKDF2-HMAC-MD5",
578 " 12000 = PBKDF2-HMAC-SHA1",
579 " 10900 = PBKDF2-HMAC-SHA256",
580 " 12100 = PBKDF2-HMAC-SHA512",
581 "",
582 "[[ Network protocols, Challenge-Response ]]",
583 "",
584 " 23 = Skype",
585 " 2500 = WPA/WPA2",
586 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
587 " 5300 = IKE-PSK MD5",
588 " 5400 = IKE-PSK SHA1",
589 " 5500 = NetNTLMv1",
590 " 5500 = NetNTLMv1 + ESS",
591 " 5600 = NetNTLMv2",
592 " 7300 = IPMI2 RAKP HMAC-SHA1",
593 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
594 " 8300 = DNSSEC (NSEC3)",
595 " 10200 = Cram MD5",
596 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
597 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
598 " 11400 = SIP digest authentication (MD5)",
599 " 13100 = Kerberos 5 TGS-REP etype 23",
600 "",
601 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
602 "",
603 " 121 = SMF (Simple Machines Forum)",
604 " 400 = phpBB3",
605 " 2611 = vBulletin < v3.8.5",
606 " 2711 = vBulletin > v3.8.5",
607 " 2811 = MyBB",
608 " 2811 = IPB (Invison Power Board)",
609 " 8400 = WBB3 (Woltlab Burning Board)",
610 " 11 = Joomla < 2.5.18",
611 " 400 = Joomla > 2.5.18",
612 " 400 = Wordpress",
613 " 2612 = PHPS",
614 " 7900 = Drupal7",
615 " 21 = osCommerce",
616 " 21 = xt:Commerce",
617 " 11000 = PrestaShop",
618 " 124 = Django (SHA-1)",
619 " 10000 = Django (PBKDF2-SHA256)",
620 " 3711 = Mediawiki B type",
621 " 7600 = Redmine",
622 "",
623 "[[ Database Server ]]",
624 "",
625 " 12 = PostgreSQL",
626 " 131 = MSSQL(2000)",
627 " 132 = MSSQL(2005)",
628 " 1731 = MSSQL(2012)",
629 " 1731 = MSSQL(2014)",
630 " 200 = MySQL323",
631 " 300 = MySQL4.1/MySQL5",
632 " 3100 = Oracle H: Type (Oracle 7+)",
633 " 112 = Oracle S: Type (Oracle 11+)",
634 " 12300 = Oracle T: Type (Oracle 12+)",
635 " 8000 = Sybase ASE",
636 "",
637 "[[ HTTP, SMTP, LDAP Server ]]",
638 "",
639 " 141 = EPiServer 6.x < v4",
640 " 1441 = EPiServer 6.x > v4",
641 " 1600 = Apache $apr1$",
642 " 12600 = ColdFusion 10+",
643 " 1421 = hMailServer",
644 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
645 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
646 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
647 "",
648 "[[ Checksums ]]",
649 "",
650 " 11500 = CRC32",
651 "",
652 "[[ Operating-Systems ]]",
653 "",
654 " 3000 = LM",
655 " 1000 = NTLM",
656 " 1100 = Domain Cached Credentials (DCC), MS Cache",
657 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
658 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
659 " 1500 = descrypt, DES(Unix), Traditional DES",
660 " 12400 = BSDiCrypt, Extended DES",
661 " 500 = md5crypt $1$, MD5(Unix)",
662 " 3200 = bcrypt $2*$, Blowfish(Unix)",
663 " 7400 = sha256crypt $5$, SHA256(Unix)",
664 " 1800 = sha512crypt $6$, SHA512(Unix)",
665 " 122 = OSX v10.4",
666 " 122 = OSX v10.5",
667 " 122 = OSX v10.6",
668 " 1722 = OSX v10.7",
669 " 7100 = OSX v10.8",
670 " 7100 = OSX v10.9",
671 " 7100 = OSX v10.10",
672 " 6300 = AIX {smd5}",
673 " 6700 = AIX {ssha1}",
674 " 6400 = AIX {ssha256}",
675 " 6500 = AIX {ssha512}",
676 " 2400 = Cisco-PIX",
677 " 2410 = Cisco-ASA",
678 " 500 = Cisco-IOS $1$",
679 " 5700 = Cisco-IOS $4$",
680 " 9200 = Cisco-IOS $8$",
681 " 9300 = Cisco-IOS $9$",
682 " 22 = Juniper Netscreen/SSG (ScreenOS)",
683 " 501 = Juniper IVE",
684 " 5800 = Android PIN",
685 " 8100 = Citrix Netscaler",
686 " 8500 = RACF",
687 " 7200 = GRUB 2",
688 " 9900 = Radmin2",
689 " 125 = ArubaOS",
690 "",
691 "[[ Enterprise Application Software (EAS) ]]",
692 "",
693 " 7700 = SAP CODVN B (BCODE)",
694 " 7800 = SAP CODVN F/G (PASSCODE)",
695 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
696 " 8600 = Lotus Notes/Domino 5",
697 " 8700 = Lotus Notes/Domino 6",
698 " 9100 = Lotus Notes/Domino 8",
699 " 133 = PeopleSoft",
700 " 13500 = PeopleSoft Token",
701 "",
702 "[[ Archives ]]",
703 "",
704 " 11600 = 7-Zip",
705 " 12500 = RAR3-hp",
706 " 13000 = RAR5",
707 " 13200 = AxCrypt",
708 " 13300 = AxCrypt in memory SHA1",
709 "",
710 "[[ Full-Disk encryptions (FDE) ]]",
711 "",
712 " 62XY = TrueCrypt 5.0+",
713 " X = 1 = PBKDF2-HMAC-RipeMD160",
714 " X = 2 = PBKDF2-HMAC-SHA512",
715 " X = 3 = PBKDF2-HMAC-Whirlpool",
716 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
717 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
718 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
719 " Y = 3 = XTS 1536 bit (Ciphers: All)",
720 " 8800 = Android FDE < v4.3",
721 " 12900 = Android FDE (Samsung DEK)",
722 " 12200 = eCryptfs",
723 "",
724 "[[ Documents ]]",
725 "",
726 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
727 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
728 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
729 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
730 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
731 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
732 " 9400 = MS Office 2007",
733 " 9500 = MS Office 2010",
734 " 9600 = MS Office 2013",
735 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
736 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
737 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
738 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
739 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
740 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
741 "",
742 "[[ Password Managers ]]",
743 "",
744 " 9000 = Password Safe v2",
745 " 5200 = Password Safe v3",
746 " 6800 = Lastpass",
747 " 6600 = 1Password, agilekeychain",
748 " 8200 = 1Password, cloudkeychain",
749 " 11300 = Bitcoin/Litecoin wallet.dat",
750 " 12700 = Blockchain, My Wallet",
751 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
752 "",
753 NULL
754 };
755
756 /**
757 * oclHashcat specific functions
758 */
759
760 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
761 {
762 int exec_pos = (int) device_param->exec_pos - last_num_entries;
763
764 if (exec_pos < 0) exec_pos += EXEC_CACHE;
765
766 double exec_ms_sum = 0;
767
768 int exec_ms_cnt = 0;
769
770 for (int i = 0; i < last_num_entries; i++)
771 {
772 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
773
774 if (exec_ms)
775 {
776 exec_ms_sum += exec_ms;
777
778 exec_ms_cnt++;
779 }
780 }
781
782 if (exec_ms_cnt == 0) return 0;
783
784 return exec_ms_sum / exec_ms_cnt;
785 }
786
787 void status_display_automat ()
788 {
789 FILE *out = stdout;
790
791 fprintf (out, "STATUS\t%u\t", data.devices_status);
792
793 /**
794 * speed new
795 */
796
797 fprintf (out, "SPEED\t");
798
799 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
800 {
801 hc_device_param_t *device_param = &data.devices_param[device_id];
802
803 if (device_param->skipped) continue;
804
805 u64 speed_cnt = 0;
806 double speed_ms = 0;
807
808 for (int i = 0; i < SPEED_CACHE; i++)
809 {
810 speed_cnt += device_param->speed_cnt[i];
811 speed_ms += device_param->speed_ms[i];
812 }
813
814 speed_cnt /= SPEED_CACHE;
815 speed_ms /= SPEED_CACHE;
816
817 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
818 }
819
820 /**
821 * exec time
822 */
823
824 fprintf (out, "EXEC_RUNTIME\t");
825
826 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
827 {
828 hc_device_param_t *device_param = &data.devices_param[device_id];
829
830 if (device_param->skipped) continue;
831
832 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
833
834 fprintf (out, "%f\t", exec_ms_avg);
835 }
836
837 /**
838 * words_cur
839 */
840
841 u64 words_cur = get_lowest_words_done ();
842
843 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
844
845 /**
846 * counter
847 */
848
849 u64 progress_total = data.words_cnt * data.salts_cnt;
850
851 u64 all_done = 0;
852 u64 all_rejected = 0;
853 u64 all_restored = 0;
854
855 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
856 {
857 all_done += data.words_progress_done[salt_pos];
858 all_rejected += data.words_progress_rejected[salt_pos];
859 all_restored += data.words_progress_restored[salt_pos];
860 }
861
862 u64 progress_cur = all_restored + all_done + all_rejected;
863 u64 progress_end = progress_total;
864
865 u64 progress_skip = 0;
866
867 if (data.skip)
868 {
869 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
870
871 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
872 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
873 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
874 }
875
876 if (data.limit)
877 {
878 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
879
880 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
881 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
882 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
883 }
884
885 u64 progress_cur_relative_skip = progress_cur - progress_skip;
886 u64 progress_end_relative_skip = progress_end - progress_skip;
887
888 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
889
890 /**
891 * cracks
892 */
893
894 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
895 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
896
897 /**
898 * temperature
899 */
900
901 #ifdef HAVE_HWMON
902 if (data.gpu_temp_disable == 0)
903 {
904 fprintf (out, "TEMP\t");
905
906 hc_thread_mutex_lock (mux_adl);
907
908 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
909 {
910 hc_device_param_t *device_param = &data.devices_param[device_id];
911
912 if (device_param->skipped) continue;
913
914 int temp = hm_get_temperature_with_device_id (device_id);
915
916 fprintf (out, "%d\t", temp);
917 }
918
919 hc_thread_mutex_unlock (mux_adl);
920 }
921 #endif // HAVE_HWMON
922
923 /**
924 * flush
925 */
926
927 #ifdef _WIN
928 fputc ('\r', out);
929 fputc ('\n', out);
930 #endif
931
932 #ifdef _POSIX
933 fputc ('\n', out);
934 #endif
935
936 fflush (out);
937 }
938
939 void status_display ()
940 {
941 if (data.devices_status == STATUS_INIT) return;
942 if (data.devices_status == STATUS_STARTING) return;
943 if (data.devices_status == STATUS_BYPASS) return;
944
945 if (data.status_automat == 1)
946 {
947 status_display_automat ();
948
949 return;
950 }
951
952 char tmp_buf[1000] = { 0 };
953
954 uint tmp_len = 0;
955
956 log_info ("Session.Name...: %s", data.session);
957
958 char *status_type = strstatus (data.devices_status);
959
960 uint hash_mode = data.hash_mode;
961
962 char *hash_type = strhashtype (hash_mode); // not a bug
963
964 log_info ("Status.........: %s", status_type);
965
966 /**
967 * show rules
968 */
969
970 if (data.rp_files_cnt)
971 {
972 uint i;
973
974 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
975 {
976 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
977 }
978
979 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
980
981 log_info ("Rules.Type.....: %s", tmp_buf);
982
983 tmp_len = 0;
984 }
985
986 if (data.rp_gen)
987 {
988 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
989
990 if (data.rp_gen_seed)
991 {
992 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
993 }
994 }
995
996 /**
997 * show input
998 */
999
1000 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1001 {
1002 if (data.wordlist_mode == WL_MODE_FILE)
1003 {
1004 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1005 }
1006 else if (data.wordlist_mode == WL_MODE_STDIN)
1007 {
1008 log_info ("Input.Mode.....: Pipe");
1009 }
1010 }
1011 else if (data.attack_mode == ATTACK_MODE_COMBI)
1012 {
1013 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1014 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1015 }
1016 else if (data.attack_mode == ATTACK_MODE_BF)
1017 {
1018 char *mask = data.mask;
1019
1020 if (mask != NULL)
1021 {
1022 uint mask_len = data.css_cnt;
1023
1024 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1025
1026 if (mask_len > 0)
1027 {
1028 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1029 {
1030 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1031 {
1032 mask_len -= data.salts_buf[0].salt_len;
1033 }
1034 }
1035
1036 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1037
1038 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1039 }
1040
1041 if (data.maskcnt > 1)
1042 {
1043 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1044
1045 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1046 }
1047
1048 log_info ("Input.Mode.....: %s", tmp_buf);
1049 }
1050
1051 tmp_len = 0;
1052 }
1053 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1054 {
1055 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1056 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1057 }
1058 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1059 {
1060 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1061 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1062 }
1063
1064 if (data.digests_cnt == 1)
1065 {
1066 if (data.hash_mode == 2500)
1067 {
1068 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1069
1070 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1071 (char *) data.salts_buf[0].salt_buf,
1072 wpa->orig_mac1[0],
1073 wpa->orig_mac1[1],
1074 wpa->orig_mac1[2],
1075 wpa->orig_mac1[3],
1076 wpa->orig_mac1[4],
1077 wpa->orig_mac1[5],
1078 wpa->orig_mac2[0],
1079 wpa->orig_mac2[1],
1080 wpa->orig_mac2[2],
1081 wpa->orig_mac2[3],
1082 wpa->orig_mac2[4],
1083 wpa->orig_mac2[5]);
1084 }
1085 else if (data.hash_mode == 5200)
1086 {
1087 log_info ("Hash.Target....: File (%s)", data.hashfile);
1088 }
1089 else if (data.hash_mode == 9000)
1090 {
1091 log_info ("Hash.Target....: File (%s)", data.hashfile);
1092 }
1093 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1094 {
1095 log_info ("Hash.Target....: File (%s)", data.hashfile);
1096 }
1097 else
1098 {
1099 char out_buf[HCBUFSIZ] = { 0 };
1100
1101 ascii_digest (out_buf, 0, 0);
1102
1103 // limit length
1104 if (strlen (out_buf) > 40)
1105 {
1106 out_buf[41] = '.';
1107 out_buf[42] = '.';
1108 out_buf[43] = '.';
1109 out_buf[44] = 0;
1110 }
1111
1112 log_info ("Hash.Target....: %s", out_buf);
1113 }
1114 }
1115 else
1116 {
1117 if (data.hash_mode == 3000)
1118 {
1119 char out_buf1[32] = { 0 };
1120 char out_buf2[32] = { 0 };
1121
1122 ascii_digest (out_buf1, 0, 0);
1123 ascii_digest (out_buf2, 0, 1);
1124
1125 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1126 }
1127 else
1128 {
1129 log_info ("Hash.Target....: File (%s)", data.hashfile);
1130 }
1131 }
1132
1133 log_info ("Hash.Type......: %s", hash_type);
1134
1135 /**
1136 * speed new
1137 */
1138
1139 u64 speed_cnt[DEVICES_MAX] = { 0 };
1140 double speed_ms[DEVICES_MAX] = { 0 };
1141
1142 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1143 {
1144 hc_device_param_t *device_param = &data.devices_param[device_id];
1145
1146 if (device_param->skipped) continue;
1147
1148 speed_cnt[device_id] = 0;
1149 speed_ms[device_id] = 0;
1150
1151 for (int i = 0; i < SPEED_CACHE; i++)
1152 {
1153 speed_cnt[device_id] += device_param->speed_cnt[i];
1154 speed_ms[device_id] += device_param->speed_ms[i];
1155 }
1156
1157 speed_cnt[device_id] /= SPEED_CACHE;
1158 speed_ms[device_id] /= SPEED_CACHE;
1159 }
1160
1161 float hashes_all_ms = 0;
1162
1163 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1164
1165 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1166 {
1167 hc_device_param_t *device_param = &data.devices_param[device_id];
1168
1169 if (device_param->skipped) continue;
1170
1171 hashes_dev_ms[device_id] = 0;
1172
1173 if (speed_ms[device_id])
1174 {
1175 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1176
1177 hashes_all_ms += hashes_dev_ms[device_id];
1178 }
1179 }
1180
1181 /**
1182 * exec time
1183 */
1184
1185 double exec_all_ms[DEVICES_MAX] = { 0 };
1186
1187 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1188 {
1189 hc_device_param_t *device_param = &data.devices_param[device_id];
1190
1191 if (device_param->skipped) continue;
1192
1193 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1194
1195 exec_all_ms[device_id] = exec_ms_avg;
1196 }
1197
1198 /**
1199 * timers
1200 */
1201
1202 double ms_running = 0;
1203
1204 hc_timer_get (data.timer_running, ms_running);
1205
1206 double ms_paused = data.ms_paused;
1207
1208 if (data.devices_status == STATUS_PAUSED)
1209 {
1210 double ms_paused_tmp = 0;
1211
1212 hc_timer_get (data.timer_paused, ms_paused_tmp);
1213
1214 ms_paused += ms_paused_tmp;
1215 }
1216
1217 #ifdef WIN
1218
1219 __time64_t sec_run = ms_running / 1000;
1220
1221 #else
1222
1223 time_t sec_run = ms_running / 1000;
1224
1225 #endif
1226
1227 if (sec_run)
1228 {
1229 char display_run[32] = { 0 };
1230
1231 struct tm tm_run;
1232
1233 struct tm *tmp = NULL;
1234
1235 #ifdef WIN
1236
1237 tmp = _gmtime64 (&sec_run);
1238
1239 #else
1240
1241 tmp = gmtime (&sec_run);
1242
1243 #endif
1244
1245 if (tmp != NULL)
1246 {
1247 memset (&tm_run, 0, sizeof (tm_run));
1248
1249 memcpy (&tm_run, tmp, sizeof (tm_run));
1250
1251 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1252
1253 char *start = ctime (&data.proc_start);
1254
1255 size_t start_len = strlen (start);
1256
1257 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1258 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1259
1260 log_info ("Time.Started...: %s (%s)", start, display_run);
1261 }
1262 }
1263 else
1264 {
1265 log_info ("Time.Started...: 0 secs");
1266 }
1267
1268 /**
1269 * counters
1270 */
1271
1272 u64 progress_total = data.words_cnt * data.salts_cnt;
1273
1274 u64 all_done = 0;
1275 u64 all_rejected = 0;
1276 u64 all_restored = 0;
1277
1278 u64 progress_noneed = 0;
1279
1280 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1281 {
1282 all_done += data.words_progress_done[salt_pos];
1283 all_rejected += data.words_progress_rejected[salt_pos];
1284 all_restored += data.words_progress_restored[salt_pos];
1285
1286 // Important for ETA only
1287
1288 if (data.salts_shown[salt_pos] == 1)
1289 {
1290 const u64 all = data.words_progress_done[salt_pos]
1291 + data.words_progress_rejected[salt_pos]
1292 + data.words_progress_restored[salt_pos];
1293
1294 const u64 left = data.words_cnt - all;
1295
1296 progress_noneed += left;
1297 }
1298 }
1299
1300 u64 progress_cur = all_restored + all_done + all_rejected;
1301 u64 progress_end = progress_total;
1302
1303 u64 progress_skip = 0;
1304
1305 if (data.skip)
1306 {
1307 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1308
1309 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1310 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1311 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1312 }
1313
1314 if (data.limit)
1315 {
1316 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1317
1318 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1319 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1320 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1321 }
1322
1323 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1324 u64 progress_end_relative_skip = progress_end - progress_skip;
1325
1326 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1327 {
1328 if (data.devices_status != STATUS_CRACKED)
1329 {
1330 #ifdef WIN
1331 __time64_t sec_etc = 0;
1332 #else
1333 time_t sec_etc = 0;
1334 #endif
1335
1336 if (hashes_all_ms)
1337 {
1338 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1339
1340 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1341
1342 sec_etc = ms_left / 1000;
1343 }
1344
1345 if (sec_etc == 0)
1346 {
1347 //log_info ("Time.Estimated.: 0 secs");
1348 }
1349 else if ((u64) sec_etc > ETC_MAX)
1350 {
1351 log_info ("Time.Estimated.: > 10 Years");
1352 }
1353 else
1354 {
1355 char display_etc[32] = { 0 };
1356
1357 struct tm tm_etc;
1358
1359 struct tm *tmp = NULL;
1360
1361 #ifdef WIN
1362
1363 tmp = _gmtime64 (&sec_etc);
1364
1365 #else
1366
1367 tmp = gmtime (&sec_etc);
1368
1369 #endif
1370
1371 if (tmp != NULL)
1372 {
1373 memset (&tm_etc, 0, sizeof (tm_etc));
1374
1375 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1376
1377 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1378
1379 time_t now;
1380
1381 time (&now);
1382
1383 now += sec_etc;
1384
1385 char *etc = ctime (&now);
1386
1387 size_t etc_len = strlen (etc);
1388
1389 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1390 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1391
1392 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1393 }
1394 }
1395 }
1396 }
1397
1398 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1399 {
1400 hc_device_param_t *device_param = &data.devices_param[device_id];
1401
1402 if (device_param->skipped) continue;
1403
1404 char display_dev_cur[16] = { 0 };
1405
1406 strncpy (display_dev_cur, "0.00", 4);
1407
1408 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1409
1410 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1411 }
1412
1413 char display_all_cur[16] = { 0 };
1414
1415 strncpy (display_all_cur, "0.00", 4);
1416
1417 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1418
1419 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1420
1421 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1422 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1423
1424 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);
1425
1426 // crack-per-time
1427
1428 if (data.digests_cnt > 100)
1429 {
1430 time_t now = time (NULL);
1431
1432 int cpt_cur_min = 0;
1433 int cpt_cur_hour = 0;
1434 int cpt_cur_day = 0;
1435
1436 for (int i = 0; i < CPT_BUF; i++)
1437 {
1438 const uint cracked = data.cpt_buf[i].cracked;
1439 const time_t timestamp = data.cpt_buf[i].timestamp;
1440
1441 if ((timestamp + 60) > now)
1442 {
1443 cpt_cur_min += cracked;
1444 }
1445
1446 if ((timestamp + 3600) > now)
1447 {
1448 cpt_cur_hour += cracked;
1449 }
1450
1451 if ((timestamp + 86400) > now)
1452 {
1453 cpt_cur_day += cracked;
1454 }
1455 }
1456
1457 double ms_real = ms_running - ms_paused;
1458
1459 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1460 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1461 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1462
1463 if ((data.cpt_start + 86400) < now)
1464 {
1465 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1466 cpt_cur_min,
1467 cpt_cur_hour,
1468 cpt_cur_day,
1469 cpt_avg_min,
1470 cpt_avg_hour,
1471 cpt_avg_day);
1472 }
1473 else if ((data.cpt_start + 3600) < now)
1474 {
1475 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1476 cpt_cur_min,
1477 cpt_cur_hour,
1478 cpt_avg_min,
1479 cpt_avg_hour,
1480 cpt_avg_day);
1481 }
1482 else if ((data.cpt_start + 60) < now)
1483 {
1484 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1485 cpt_cur_min,
1486 cpt_avg_min,
1487 cpt_avg_hour,
1488 cpt_avg_day);
1489 }
1490 else
1491 {
1492 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1493 cpt_avg_min,
1494 cpt_avg_hour,
1495 cpt_avg_day);
1496 }
1497 }
1498
1499 // Restore point
1500
1501 u64 restore_point = get_lowest_words_done ();
1502
1503 u64 restore_total = data.words_base;
1504
1505 float percent_restore = 0;
1506
1507 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1508
1509 if (progress_end_relative_skip)
1510 {
1511 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1512 {
1513 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1514 float percent_rejected = 0.0;
1515
1516 if (progress_cur)
1517 {
1518 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1519 }
1520
1521 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);
1522 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1523
1524 if (data.restore_disable == 0)
1525 {
1526 if (percent_finished != 1)
1527 {
1528 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1529 }
1530 }
1531 }
1532 }
1533 else
1534 {
1535 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1536 {
1537 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1538 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1539
1540 if (data.restore_disable == 0)
1541 {
1542 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1543 }
1544 }
1545 else
1546 {
1547 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1548 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1549
1550 // --restore not allowed if stdin is used -- really? why?
1551
1552 //if (data.restore_disable == 0)
1553 //{
1554 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1555 //}
1556 }
1557 }
1558
1559 #ifdef HAVE_HWMON
1560 if (data.gpu_temp_disable == 0)
1561 {
1562 hc_thread_mutex_lock (mux_adl);
1563
1564 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1565 {
1566 hc_device_param_t *device_param = &data.devices_param[device_id];
1567
1568 if (device_param->skipped) continue;
1569
1570 #define HM_STR_BUF_SIZE 255
1571
1572 if (data.hm_device[device_id].fan_supported == 1)
1573 {
1574 char utilization[HM_STR_BUF_SIZE] = { 0 };
1575 char temperature[HM_STR_BUF_SIZE] = { 0 };
1576 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1577
1578 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1579 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1580
1581 if (device_param->vendor_id == VENDOR_ID_AMD)
1582 {
1583 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1584 }
1585 else if (device_param->vendor_id == VENDOR_ID_NV)
1586 {
1587 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1588 }
1589
1590 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1591 }
1592 else
1593 {
1594 char utilization[HM_STR_BUF_SIZE] = { 0 };
1595 char temperature[HM_STR_BUF_SIZE] = { 0 };
1596
1597 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1598 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1599
1600 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1601 }
1602 }
1603
1604 hc_thread_mutex_unlock (mux_adl);
1605 }
1606 #endif // HAVE_HWMON
1607 }
1608
1609 static void status_benchmark ()
1610 {
1611 if (data.devices_status == STATUS_INIT) return;
1612 if (data.devices_status == STATUS_STARTING) return;
1613
1614 if (data.words_cnt == 0) return;
1615
1616 u64 speed_cnt[DEVICES_MAX] = { 0 };
1617 double speed_ms[DEVICES_MAX] = { 0 };
1618
1619 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1620 {
1621 hc_device_param_t *device_param = &data.devices_param[device_id];
1622
1623 if (device_param->skipped) continue;
1624
1625 speed_cnt[device_id] = device_param->speed_cnt[0];
1626 speed_ms[device_id] = device_param->speed_ms[0];
1627 }
1628
1629 float hashes_all_ms = 0;
1630
1631 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1632
1633 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1634 {
1635 hc_device_param_t *device_param = &data.devices_param[device_id];
1636
1637 if (device_param->skipped) continue;
1638
1639 hashes_dev_ms[device_id] = 0;
1640
1641 if (speed_ms[device_id])
1642 {
1643 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1644
1645 hashes_all_ms += hashes_dev_ms[device_id];
1646 }
1647 }
1648
1649 /**
1650 * exec time
1651 */
1652
1653 double exec_all_ms[DEVICES_MAX] = { 0 };
1654
1655 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1656 {
1657 hc_device_param_t *device_param = &data.devices_param[device_id];
1658
1659 if (device_param->skipped) continue;
1660
1661 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1662
1663 exec_all_ms[device_id] = exec_ms_avg;
1664 }
1665
1666 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1667 {
1668 hc_device_param_t *device_param = &data.devices_param[device_id];
1669
1670 if (device_param->skipped) continue;
1671
1672 char display_dev_cur[16] = { 0 };
1673
1674 strncpy (display_dev_cur, "0.00", 4);
1675
1676 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1677
1678 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1679 }
1680
1681 char display_all_cur[16] = { 0 };
1682
1683 strncpy (display_all_cur, "0.00", 4);
1684
1685 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1686
1687 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1688 }
1689
1690 /**
1691 * oclHashcat -only- functions
1692 */
1693
1694 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1695 {
1696 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1697 {
1698 if (attack_kern == ATTACK_KERN_STRAIGHT)
1699 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1700 else if (attack_kern == ATTACK_KERN_COMBI)
1701 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1702 else if (attack_kern == ATTACK_KERN_BF)
1703 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1704 }
1705 else
1706 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1707 }
1708
1709 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)
1710 {
1711 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1712 {
1713 if (attack_kern == ATTACK_KERN_STRAIGHT)
1714 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1715 else if (attack_kern == ATTACK_KERN_COMBI)
1716 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1717 else if (attack_kern == ATTACK_KERN_BF)
1718 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1719 }
1720 else
1721 {
1722 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1723 }
1724 }
1725
1726 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1727 {
1728 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1729 {
1730 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1731 }
1732 else
1733 {
1734 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1735 }
1736 }
1737
1738 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)
1739 {
1740 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1741 {
1742 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1743 }
1744 else
1745 {
1746 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1747 }
1748 }
1749
1750 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1751 {
1752 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1753 }
1754
1755 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1756 {
1757 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1758 }
1759
1760 static uint convert_from_hex (char *line_buf, const uint line_len)
1761 {
1762 if (line_len & 1) return (line_len); // not in hex
1763
1764 if (data.hex_wordlist == 1)
1765 {
1766 uint i;
1767 uint j;
1768
1769 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1770 {
1771 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1772 }
1773
1774 memset (line_buf + i, 0, line_len - i);
1775
1776 return (i);
1777 }
1778 else if (line_len >= 6) // $HEX[] = 6
1779 {
1780 if (line_buf[0] != '$') return (line_len);
1781 if (line_buf[1] != 'H') return (line_len);
1782 if (line_buf[2] != 'E') return (line_len);
1783 if (line_buf[3] != 'X') return (line_len);
1784 if (line_buf[4] != '[') return (line_len);
1785 if (line_buf[line_len - 1] != ']') return (line_len);
1786
1787 uint i;
1788 uint j;
1789
1790 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1791 {
1792 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1793 }
1794
1795 memset (line_buf + i, 0, line_len - i);
1796
1797 return (i);
1798 }
1799
1800 return (line_len);
1801 }
1802
1803 static void clear_prompt ()
1804 {
1805 fputc ('\r', stdout);
1806
1807 for (size_t i = 0; i < strlen (PROMPT); i++)
1808 {
1809 fputc (' ', stdout);
1810 }
1811
1812 fputc ('\r', stdout);
1813
1814 fflush (stdout);
1815 }
1816
1817 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1818 {
1819 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);
1820 }
1821
1822 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1823 {
1824 char *outfile = data.outfile;
1825 uint quiet = data.quiet;
1826 FILE *pot_fp = data.pot_fp;
1827 uint loopback = data.loopback;
1828 uint debug_mode = data.debug_mode;
1829 char *debug_file = data.debug_file;
1830
1831 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1832 int debug_rule_len = 0; // -1 error
1833 uint debug_plain_len = 0;
1834
1835 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1836
1837 // hash
1838
1839 char out_buf[HCBUFSIZ] = { 0 };
1840
1841 ascii_digest (out_buf, salt_pos, digest_pos);
1842
1843 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1844
1845 // plain
1846
1847 plain_t plain;
1848
1849 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);
1850
1851 uint gidvid = plain.gidvid;
1852 uint il_pos = plain.il_pos;
1853
1854 u64 crackpos = device_param->words_off;
1855
1856 uint plain_buf[16] = { 0 };
1857
1858 u8 *plain_ptr = (u8 *) plain_buf;
1859 unsigned int plain_len = 0;
1860
1861 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1862 {
1863 u64 gidd = gidvid;
1864 u64 gidm = 0;
1865
1866 pw_t pw;
1867
1868 gidd_to_pw_t (device_param, gidd, &pw);
1869
1870 for (int i = 0, j = gidm; i < 16; i++, j++)
1871 {
1872 plain_buf[i] = pw.i[j];
1873 }
1874
1875 plain_len = pw.pw_len;
1876
1877 const uint off = device_param->innerloop_pos + il_pos;
1878
1879 if (debug_mode > 0)
1880 {
1881 debug_rule_len = 0;
1882
1883 // save rule
1884 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1885 {
1886 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1887
1888 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1889 }
1890
1891 // save plain
1892 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1893 {
1894 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1895
1896 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1897
1898 debug_plain_len = plain_len;
1899 }
1900 }
1901
1902 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1903
1904 crackpos += gidvid;
1905 crackpos *= data.kernel_rules_cnt;
1906 crackpos += device_param->innerloop_pos + il_pos;
1907
1908 if (plain_len > data.pw_max) plain_len = data.pw_max;
1909 }
1910 else if (data.attack_mode == ATTACK_MODE_COMBI)
1911 {
1912 u64 gidd = gidvid;
1913 u64 gidm = 0;
1914
1915 pw_t pw;
1916
1917 gidd_to_pw_t (device_param, gidd, &pw);
1918
1919 for (int i = 0, j = gidm; i < 16; i++, j++)
1920 {
1921 plain_buf[i] = pw.i[j];
1922 }
1923
1924 plain_len = pw.pw_len;
1925
1926 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1927 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1928
1929 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1930 {
1931 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1932 }
1933 else
1934 {
1935 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1936
1937 memcpy (plain_ptr, comb_buf, comb_len);
1938 }
1939
1940 plain_len += comb_len;
1941
1942 crackpos += gidvid;
1943 crackpos *= data.combs_cnt;
1944 crackpos += device_param->innerloop_pos + il_pos;
1945
1946 if (data.pw_max != PW_DICTMAX1)
1947 {
1948 if (plain_len > data.pw_max) plain_len = data.pw_max;
1949 }
1950 }
1951 else if (data.attack_mode == ATTACK_MODE_BF)
1952 {
1953 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1954 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1955
1956 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1957 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1958
1959 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1960 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1961
1962 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1963 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1964
1965 plain_len = data.css_cnt;
1966
1967 crackpos += gidvid;
1968 crackpos *= data.bfs_cnt;
1969 crackpos += device_param->innerloop_pos + il_pos;
1970 }
1971 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1972 {
1973 u64 gidd = gidvid;
1974 u64 gidm = 0;
1975
1976 pw_t pw;
1977
1978 gidd_to_pw_t (device_param, gidd, &pw);
1979
1980 for (int i = 0, j = gidm; i < 16; i++, j++)
1981 {
1982 plain_buf[i] = pw.i[j];
1983 }
1984
1985 plain_len = pw.pw_len;
1986
1987 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1988
1989 uint start = 0;
1990 uint stop = device_param->kernel_params_mp_buf32[4];
1991
1992 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1993
1994 plain_len += start + stop;
1995
1996 crackpos += gidvid;
1997 crackpos *= data.combs_cnt;
1998 crackpos += device_param->innerloop_pos + il_pos;
1999
2000 if (data.pw_max != PW_DICTMAX1)
2001 {
2002 if (plain_len > data.pw_max) plain_len = data.pw_max;
2003 }
2004 }
2005 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2006 {
2007 u64 gidd = gidvid;
2008 u64 gidm = 0;
2009
2010 pw_t pw;
2011
2012 gidd_to_pw_t (device_param, gidd, &pw);
2013
2014 for (int i = 0, j = gidm; i < 16; i++, j++)
2015 {
2016 plain_buf[i] = pw.i[j];
2017 }
2018
2019 plain_len = pw.pw_len;
2020
2021 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2022
2023 uint start = 0;
2024 uint stop = device_param->kernel_params_mp_buf32[4];
2025
2026 memmove (plain_ptr + stop, plain_ptr, plain_len);
2027
2028 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2029
2030 plain_len += start + stop;
2031
2032 crackpos += gidvid;
2033 crackpos *= data.combs_cnt;
2034 crackpos += device_param->innerloop_pos + il_pos;
2035
2036 if (data.pw_max != PW_DICTMAX1)
2037 {
2038 if (plain_len > data.pw_max) plain_len = data.pw_max;
2039 }
2040 }
2041
2042 if (data.attack_mode == ATTACK_MODE_BF)
2043 {
2044 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2045 {
2046 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2047 {
2048 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2049 {
2050 plain_len = plain_len - data.salts_buf[0].salt_len;
2051 }
2052 }
2053
2054 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2055 {
2056 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2057 {
2058 plain_ptr[j] = plain_ptr[i];
2059 }
2060
2061 plain_len = plain_len / 2;
2062 }
2063 }
2064 }
2065
2066 // if enabled, update also the potfile
2067
2068 if (pot_fp)
2069 {
2070 lock_file (pot_fp);
2071
2072 fprintf (pot_fp, "%s:", out_buf);
2073
2074 format_plain (pot_fp, plain_ptr, plain_len, 1);
2075
2076 fputc ('\n', pot_fp);
2077
2078 fflush (pot_fp);
2079
2080 unlock_file (pot_fp);
2081 }
2082
2083 // outfile
2084
2085 FILE *out_fp = NULL;
2086
2087 if (outfile != NULL)
2088 {
2089 if ((out_fp = fopen (outfile, "ab")) == NULL)
2090 {
2091 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2092
2093 out_fp = stdout;
2094 }
2095 lock_file (out_fp);
2096 }
2097 else
2098 {
2099 out_fp = stdout;
2100
2101 if (quiet == 0) clear_prompt ();
2102 }
2103
2104 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2105
2106 if (outfile != NULL)
2107 {
2108 if (out_fp != stdout)
2109 {
2110 fclose (out_fp);
2111 }
2112 }
2113 else
2114 {
2115 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2116 {
2117 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2118 {
2119 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2120 if (quiet == 0) fflush (stdout);
2121 }
2122 }
2123 }
2124
2125 // loopback
2126
2127 if (loopback)
2128 {
2129 char *loopback_file = data.loopback_file;
2130
2131 FILE *fb_fp = NULL;
2132
2133 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2134 {
2135 lock_file (fb_fp);
2136
2137 format_plain (fb_fp, plain_ptr, plain_len, 1);
2138
2139 fputc ('\n', fb_fp);
2140
2141 fclose (fb_fp);
2142 }
2143 }
2144
2145 // (rule) debug mode
2146
2147 // the next check implies that:
2148 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2149 // - debug_mode > 0
2150
2151 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2152 {
2153 if (debug_rule_len < 0) debug_rule_len = 0;
2154
2155 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2156
2157 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2158
2159 if ((quiet == 0) && (debug_file == NULL))
2160 {
2161 fprintf (stdout, "%s", PROMPT);
2162 fflush (stdout);
2163 }
2164 }
2165 }
2166
2167 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2168 {
2169 salt_t *salt_buf = &data.salts_buf[salt_pos];
2170
2171 int found = 0;
2172
2173 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);
2174
2175 for (uint i = 0; i < device_param->kernel_threads; i++) if (device_param->result[i] == 1) found = 1;
2176
2177 if (found == 1)
2178 {
2179 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2180
2181 log_info_nn ("");
2182
2183 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);
2184
2185 uint cpt_cracked = 0;
2186
2187 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2188 {
2189 uint idx = salt_buf->digests_offset + digest_pos;
2190
2191 if (data.digests_shown_tmp[idx] == 0) continue;
2192
2193 if (data.digests_shown[idx] == 1) continue;
2194
2195 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2196 {
2197 data.digests_shown[idx] = 1;
2198
2199 data.digests_done++;
2200
2201 cpt_cracked++;
2202
2203 salt_buf->digests_done++;
2204
2205 if (salt_buf->digests_done == salt_buf->digests_cnt)
2206 {
2207 data.salts_shown[salt_pos] = 1;
2208
2209 data.salts_done++;
2210 }
2211 }
2212
2213 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2214
2215 check_hash (device_param, salt_pos, digest_pos);
2216 }
2217
2218 if (cpt_cracked > 0)
2219 {
2220 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2221 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2222
2223 data.cpt_pos++;
2224
2225 data.cpt_total += cpt_cracked;
2226
2227 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2228 }
2229
2230 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2231 {
2232 // we need to reset cracked state on the device
2233 // otherwise host thinks again and again the hash was cracked
2234 // and returns invalid password each time
2235
2236 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2237
2238 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);
2239 }
2240
2241 memset (device_param->result, 0, device_param->size_results);
2242
2243 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);
2244 }
2245 }
2246
2247 static void save_hash ()
2248 {
2249 char *hashfile = data.hashfile;
2250
2251 char new_hashfile[256] = { 0 };
2252 char old_hashfile[256] = { 0 };
2253
2254 snprintf (new_hashfile, 255, "%s.new", hashfile);
2255 snprintf (old_hashfile, 255, "%s.old", hashfile);
2256
2257 unlink (new_hashfile);
2258
2259 char separator = data.separator;
2260
2261 FILE *fp = fopen (new_hashfile, "wb");
2262
2263 if (fp == NULL)
2264 {
2265 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2266
2267 exit (-1);
2268 }
2269
2270 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2271 {
2272 if (data.salts_shown[salt_pos] == 1) continue;
2273
2274 salt_t *salt_buf = &data.salts_buf[salt_pos];
2275
2276 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2277 {
2278 uint idx = salt_buf->digests_offset + digest_pos;
2279
2280 if (data.digests_shown[idx] == 1) continue;
2281
2282 if (data.hash_mode != 2500)
2283 {
2284 char out_buf[HCBUFSIZ] = { 0 };
2285
2286 if (data.username == 1)
2287 {
2288 user_t *user = data.hash_info[idx]->user;
2289
2290 uint i;
2291
2292 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2293
2294 fputc (separator, fp);
2295 }
2296
2297 ascii_digest (out_buf, salt_pos, digest_pos);
2298
2299 fputs (out_buf, fp);
2300
2301 log_out (fp, "");
2302 }
2303 else
2304 {
2305 hccap_t hccap;
2306
2307 to_hccap_t (&hccap, salt_pos, digest_pos);
2308
2309 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2310 }
2311 }
2312 }
2313
2314 fflush (fp);
2315
2316 fclose (fp);
2317
2318 unlink (old_hashfile);
2319
2320 if (rename (hashfile, old_hashfile) != 0)
2321 {
2322 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2323
2324 exit (-1);
2325 }
2326
2327 unlink (hashfile);
2328
2329 if (rename (new_hashfile, hashfile) != 0)
2330 {
2331 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2332
2333 exit (-1);
2334 }
2335
2336 unlink (old_hashfile);
2337 }
2338
2339 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2340 {
2341 // function called only in case kernel_power_all > words_left
2342
2343 float kernel_power_div = (float) (total_left) / kernel_power_all;
2344
2345 kernel_power_div += kernel_power_div / 100;
2346
2347 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2348
2349 while (kernel_power_new < total_left)
2350 {
2351 kernel_power_div += kernel_power_div / 100;
2352
2353 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2354 }
2355
2356 if (data.quiet == 0)
2357 {
2358 clear_prompt ();
2359
2360 log_info ("");
2361
2362 log_info ("INFO: approaching final keyspace, workload adjusted");
2363
2364 log_info ("");
2365
2366 fprintf (stdout, "%s", PROMPT);
2367
2368 fflush (stdout);
2369 }
2370
2371 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2372
2373 return kernel_power_div;
2374 }
2375
2376 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2377 {
2378 uint num_elements = num;
2379
2380 device_param->kernel_params_buf32[30] = data.combs_mode;
2381 device_param->kernel_params_buf32[31] = num;
2382
2383 uint kernel_threads = device_param->kernel_threads;
2384
2385 while (num_elements % kernel_threads) num_elements++;
2386
2387 cl_kernel kernel = NULL;
2388
2389 switch (kern_run)
2390 {
2391 case KERN_RUN_1: kernel = device_param->kernel1; break;
2392 case KERN_RUN_12: kernel = device_param->kernel12; break;
2393 case KERN_RUN_2: kernel = device_param->kernel2; break;
2394 case KERN_RUN_23: kernel = device_param->kernel23; break;
2395 case KERN_RUN_3: kernel = device_param->kernel3; break;
2396 }
2397
2398 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2399 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2400 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2401 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2402 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2403 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2404 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2405 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2406 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2407 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2408 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2409
2410 hc_timer_t timer;
2411
2412 hc_timer_set (&timer);
2413
2414 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2415 {
2416 const size_t global_work_size[3] = { num_elements, 32, 1 };
2417 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2418
2419 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2420 }
2421 else
2422 {
2423 size_t workgroup_size = 0;
2424
2425 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2426
2427 if (kern_run == KERN_RUN_2)
2428 {
2429 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2430 {
2431 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2432 }
2433 }
2434
2435 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2436
2437 while (num_elements % kernel_threads) num_elements++;
2438
2439 const size_t global_work_size[3] = { num_elements, 1, 1 };
2440 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2441
2442 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2443 }
2444
2445 hc_clFlush (data.ocl, device_param->command_queue);
2446
2447 hc_clFinish (data.ocl, device_param->command_queue);
2448
2449 if (event_update)
2450 {
2451 double exec_time;
2452
2453 hc_timer_get (timer, exec_time);
2454
2455 uint exec_pos = device_param->exec_pos;
2456
2457 device_param->exec_ms[exec_pos] = exec_time;
2458
2459 exec_pos++;
2460
2461 if (exec_pos == EXEC_CACHE)
2462 {
2463 exec_pos = 0;
2464 }
2465
2466 device_param->exec_pos = exec_pos;
2467 }
2468 }
2469
2470 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2471 {
2472 uint num_elements = num;
2473
2474 switch (kern_run)
2475 {
2476 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2477 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2478 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2479 }
2480
2481 // causes problems with special threads like in bcrypt
2482 // const uint kernel_threads = device_param->kernel_threads;
2483
2484 uint kernel_threads = device_param->kernel_threads;
2485
2486 while (num_elements % kernel_threads) num_elements++;
2487
2488 cl_kernel kernel = NULL;
2489
2490 switch (kern_run)
2491 {
2492 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2493 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2494 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2495 }
2496
2497 switch (kern_run)
2498 {
2499 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2500 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2501 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2502 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2503 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2504 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2505 break;
2506 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2507 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2508 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2509 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2510 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2511 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2512 break;
2513 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2514 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2515 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2516 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2517 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2518 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2519 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2520 break;
2521 }
2522
2523 size_t workgroup_size = 0;
2524
2525 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2526
2527 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2528
2529 const size_t global_work_size[3] = { num_elements, 1, 1 };
2530 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2531
2532 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2533
2534 hc_clFlush (data.ocl, device_param->command_queue);
2535
2536 hc_clFinish (data.ocl, device_param->command_queue);
2537 }
2538
2539 static void run_kernel_tm (hc_device_param_t *device_param)
2540 {
2541 const uint num_elements = 1024; // fixed
2542
2543 uint kernel_threads = 32;
2544
2545 cl_kernel kernel = device_param->kernel_tm;
2546
2547 size_t workgroup_size = 0;
2548
2549 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2550
2551 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2552
2553 const size_t global_work_size[3] = { num_elements, 1, 1 };
2554 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2555
2556 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2557
2558 hc_clFlush (data.ocl, device_param->command_queue);
2559
2560 hc_clFinish (data.ocl, device_param->command_queue);
2561 }
2562
2563 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2564 {
2565 uint num_elements = num;
2566
2567 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2568 device_param->kernel_params_amp_buf32[6] = num_elements;
2569
2570 // causes problems with special threads like in bcrypt
2571 // const uint kernel_threads = device_param->kernel_threads;
2572
2573 uint kernel_threads = device_param->kernel_threads;
2574
2575 while (num_elements % kernel_threads) num_elements++;
2576
2577 cl_kernel kernel = device_param->kernel_amp;
2578
2579 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2580 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2581
2582 size_t workgroup_size = 0;
2583
2584 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2585
2586 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2587
2588 const size_t global_work_size[3] = { num_elements, 1, 1 };
2589 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2590
2591 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2592
2593 hc_clFlush (data.ocl, device_param->command_queue);
2594
2595 hc_clFinish (data.ocl, device_param->command_queue);
2596 }
2597
2598 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2599 {
2600 int rc = -1;
2601
2602 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2603 {
2604 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2605
2606 const cl_uchar zero = 0;
2607
2608 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2609 }
2610
2611 if (rc != 0)
2612 {
2613 // NOTE: clEnqueueFillBuffer () always fails with -59
2614 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2615 // How's that possible, OpenCL 1.2 support is advertised??
2616 // We need to workaround...
2617
2618 #define FILLSZ 0x100000
2619
2620 char *tmp = (char *) mymalloc (FILLSZ);
2621
2622 for (size_t i = 0; i < size; i += FILLSZ)
2623 {
2624 const size_t left = size - i;
2625
2626 const size_t fillsz = MIN (FILLSZ, left);
2627
2628 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2629 }
2630
2631 myfree (tmp);
2632 }
2633 }
2634
2635 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)
2636 {
2637 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2638 {
2639 if (attack_mode == ATTACK_MODE_BF)
2640 {
2641 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2642 {
2643 const uint size_tm = 32 * sizeof (bs_word_t);
2644
2645 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2646
2647 run_kernel_tm (device_param);
2648
2649 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);
2650 }
2651 }
2652
2653 if (highest_pw_len < 16)
2654 {
2655 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2656 }
2657 else if (highest_pw_len < 32)
2658 {
2659 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2660 }
2661 else
2662 {
2663 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2664 }
2665 }
2666 else
2667 {
2668 run_kernel_amp (device_param, pws_cnt);
2669
2670 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2671
2672 if (opts_type & OPTS_TYPE_HOOK12)
2673 {
2674 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2675 }
2676
2677 uint iter = salt_buf->salt_iter;
2678
2679 uint loop_step = device_param->kernel_loops;
2680
2681 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2682 {
2683 uint loop_left = iter - loop_pos;
2684
2685 loop_left = MIN (loop_left, loop_step);
2686
2687 device_param->kernel_params_buf32[25] = loop_pos;
2688 device_param->kernel_params_buf32[26] = loop_left;
2689
2690 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2691
2692 if (data.devices_status == STATUS_CRACKED) break;
2693 if (data.devices_status == STATUS_ABORTED) break;
2694 if (data.devices_status == STATUS_QUIT) break;
2695
2696 /**
2697 * speed
2698 */
2699
2700 const float iter_part = (float) (loop_pos + loop_left) / iter;
2701
2702 const u64 perf_sum_all = pws_cnt * iter_part;
2703
2704 double speed_ms;
2705
2706 hc_timer_get (device_param->timer_speed, speed_ms);
2707
2708 const u32 speed_pos = device_param->speed_pos;
2709
2710 device_param->speed_cnt[speed_pos] = perf_sum_all;
2711
2712 device_param->speed_ms[speed_pos] = speed_ms;
2713 }
2714
2715 if (opts_type & OPTS_TYPE_HOOK23)
2716 {
2717 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2718
2719 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);
2720
2721 // do something with data
2722
2723 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);
2724 }
2725
2726 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2727 }
2728 }
2729
2730 static int run_rule_engine (const int rule_len, const char *rule_buf)
2731 {
2732 if (rule_len == 0)
2733 {
2734 return 0;
2735 }
2736 else if (rule_len == 1)
2737 {
2738 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2739 }
2740
2741 return 1;
2742 }
2743
2744 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2745 {
2746 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2747 {
2748 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);
2749 }
2750 else if (data.attack_kern == ATTACK_KERN_COMBI)
2751 {
2752 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2753 {
2754 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2755 {
2756 for (u32 i = 0; i < pws_cnt; i++)
2757 {
2758 const u32 pw_len = device_param->pws_buf[i].pw_len;
2759
2760 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2761
2762 ptr[pw_len] = 0x01;
2763 }
2764 }
2765 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2766 {
2767 for (u32 i = 0; i < pws_cnt; i++)
2768 {
2769 const u32 pw_len = device_param->pws_buf[i].pw_len;
2770
2771 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2772
2773 ptr[pw_len] = 0x80;
2774 }
2775 }
2776 }
2777
2778 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);
2779 }
2780 else if (data.attack_kern == ATTACK_KERN_BF)
2781 {
2782 const u64 off = device_param->words_off;
2783
2784 device_param->kernel_params_mp_l_buf64[3] = off;
2785
2786 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2787 }
2788 }
2789
2790 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2791 {
2792 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2793
2794 device_param->kernel_params_buf32[25] = 0;
2795 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2796 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2797
2798 // init some fake words
2799
2800 if (data.hash_mode == 10700)
2801 {
2802 // hash mode 10700 hangs on length 0 (unlimited loop)
2803
2804 for (u32 i = 0; i < kernel_power; i++)
2805 {
2806 device_param->pws_buf[i].i[0] = i;
2807 device_param->pws_buf[i].i[1] = i + 0x01234567;
2808 device_param->pws_buf[i].i[2] = i + 0x89abcdef;
2809 device_param->pws_buf[i].i[3] = 0xffffffff;
2810 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2811 }
2812
2813 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);
2814
2815 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2816 {
2817 run_kernel_amp (device_param, kernel_power);
2818 }
2819 }
2820
2821 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2822 {
2823 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2824 }
2825 else
2826 {
2827 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2828 }
2829
2830 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2831
2832 // reset fake words
2833
2834 if (data.hash_mode == 10700)
2835 {
2836 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
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 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);
2840 }
2841
2842 return exec_ms_prev;
2843 }
2844
2845 static void autotune (hc_device_param_t *device_param)
2846 {
2847 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2848
2849 const u32 kernel_accel_min = device_param->kernel_accel_min;
2850 const u32 kernel_accel_max = device_param->kernel_accel_max;
2851
2852 const u32 kernel_loops_min = device_param->kernel_loops_min;
2853 const u32 kernel_loops_max = device_param->kernel_loops_max;
2854
2855 u32 kernel_accel = kernel_accel_min;
2856 u32 kernel_loops = kernel_loops_min;
2857
2858 #define STEPS_CNT 10
2859
2860 #define MAX_RETRIES 1
2861
2862 double exec_ms_final = 0;
2863
2864 // first find out highest kernel-loops that stays below target_ms
2865
2866 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2867 {
2868 double exec_ms_best = try_run (device_param, kernel_accel_min, kernel_loops);
2869
2870 for (int i = 0; i < MAX_RETRIES; i++)
2871 {
2872 const double exec_ms_cur = try_run (device_param, kernel_accel_min, kernel_loops);
2873
2874 exec_ms_best = MIN (exec_ms_best, exec_ms_cur);
2875 }
2876
2877 if (exec_ms_final == 0) exec_ms_final = exec_ms_best;
2878
2879 if (exec_ms_best < target_ms) break;
2880 }
2881
2882 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2883
2884 if (kernel_accel_min < kernel_accel_max)
2885 {
2886 for (int i = 0; i < STEPS_CNT; i++)
2887 {
2888 const u32 kernel_accel_try = 1 << i;
2889
2890 if (kernel_accel_try < kernel_accel_min) continue;
2891 if (kernel_accel_try > kernel_accel_max) break;
2892
2893 double exec_ms_best = try_run (device_param, kernel_accel_try, kernel_loops);
2894
2895 for (int i = 0; i < MAX_RETRIES; i++)
2896 {
2897 const double exec_ms_cur = try_run (device_param, kernel_accel_try, kernel_loops);
2898
2899 exec_ms_best = MIN (exec_ms_best, exec_ms_cur);
2900 }
2901
2902 if (exec_ms_best > target_ms) break;
2903
2904 exec_ms_final = exec_ms_best;
2905
2906 kernel_accel = kernel_accel_try;
2907 }
2908 }
2909
2910 // sometimes we're in a bad situation that the algorithm is so slow that we can not
2911 // create enough kernel_accel to do both, keep the gpu busy and stay below target_ms.
2912 // however, we need to have a minimum kernel_accel of 8.
2913 // luckily, at this level of workload, it became a linear function
2914
2915 while (kernel_accel < 8)
2916 {
2917 const u32 kernel_accel_try = kernel_accel * 2;
2918 const u32 kernel_loops_try = kernel_loops / 2;
2919
2920 if (kernel_accel_try > kernel_accel_max) break;
2921 if (kernel_loops_try < kernel_loops_min) break;
2922
2923 kernel_accel = kernel_accel_try;
2924 kernel_loops = kernel_loops_try;
2925 }
2926
2927 // finally there's a chance that we have a fixed kernel_loops but not a fixed kernel_accel
2928 // in such a case the above function would not create any change
2929 // we'll use the runtime to find out if we're allow to do last improvement
2930
2931 if (exec_ms_final > 0)
2932 {
2933 if (exec_ms_final < target_ms)
2934 {
2935 const double exec_left = target_ms / exec_ms_final;
2936
2937 const double accel_left = kernel_accel_max / kernel_accel;
2938
2939 const double exec_accel_min = MIN (exec_left, accel_left);
2940
2941 if (exec_accel_min >= 2)
2942 {
2943 kernel_accel *= exec_accel_min;
2944 }
2945 }
2946 }
2947
2948 // reset timer
2949
2950 device_param->exec_pos = 0;
2951
2952 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
2953
2954 // store
2955
2956 device_param->kernel_accel = kernel_accel;
2957 device_param->kernel_loops = kernel_loops;
2958
2959 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2960
2961 device_param->kernel_power = kernel_power;
2962
2963 #ifdef DEBUG
2964
2965 if (data.quiet == 0)
2966 {
2967 clear_prompt ();
2968
2969 log_info ("Device #%u: autotuned kernel-accel to %u\n"
2970 "Device #%u: autotuned kernel-loops to %u\n",
2971 device_param->device_id + 1, kernel_accel,
2972 device_param->device_id + 1, kernel_loops);
2973
2974 fprintf (stdout, "%s", PROMPT);
2975
2976 fflush (stdout);
2977 }
2978
2979 #endif
2980 }
2981
2982 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
2983 {
2984 char *line_buf = (char *) mymalloc (HCBUFSIZ);
2985
2986 // init speed timer
2987
2988 uint speed_pos = device_param->speed_pos;
2989
2990 #ifdef _POSIX
2991 if (device_param->timer_speed.tv_sec == 0)
2992 {
2993 hc_timer_set (&device_param->timer_speed);
2994 }
2995 #endif
2996
2997 #ifdef _WIN
2998 if (device_param->timer_speed.QuadPart == 0)
2999 {
3000 hc_timer_set (&device_param->timer_speed);
3001 }
3002 #endif
3003
3004 // find higest password length, this is for optimization stuff
3005
3006 uint highest_pw_len = 0;
3007
3008 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3009 {
3010 }
3011 else if (data.attack_kern == ATTACK_KERN_COMBI)
3012 {
3013 }
3014 else if (data.attack_kern == ATTACK_KERN_BF)
3015 {
3016 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3017 + device_param->kernel_params_mp_l_buf32[5];
3018 }
3019
3020 // iteration type
3021
3022 uint innerloop_step = 0;
3023 uint innerloop_cnt = 0;
3024
3025 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3026 else innerloop_step = 1;
3027
3028 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3029 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3030 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3031
3032 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3033
3034 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3035 {
3036 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3037
3038 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3039
3040 if (data.devices_status == STATUS_CRACKED) break;
3041 if (data.devices_status == STATUS_ABORTED) break;
3042 if (data.devices_status == STATUS_QUIT) break;
3043 if (data.devices_status == STATUS_BYPASS) break;
3044
3045 salt_t *salt_buf = &data.salts_buf[salt_pos];
3046
3047 device_param->kernel_params_buf32[24] = salt_pos;
3048 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3049 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3050
3051 FILE *combs_fp = device_param->combs_fp;
3052
3053 if (data.attack_mode == ATTACK_MODE_COMBI)
3054 {
3055 rewind (combs_fp);
3056 }
3057
3058 // innerloops
3059
3060 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3061 {
3062 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3063
3064 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3065
3066 if (data.devices_status == STATUS_CRACKED) break;
3067 if (data.devices_status == STATUS_ABORTED) break;
3068 if (data.devices_status == STATUS_QUIT) break;
3069 if (data.devices_status == STATUS_BYPASS) break;
3070
3071 uint innerloop_left = innerloop_cnt - innerloop_pos;
3072
3073 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3074
3075 device_param->innerloop_pos = innerloop_pos;
3076 device_param->innerloop_left = innerloop_left;
3077
3078 device_param->kernel_params_buf32[27] = innerloop_left;
3079
3080 // i think we can get rid of this
3081 if (innerloop_left == 0)
3082 {
3083 puts ("bug, how should this happen????\n");
3084
3085 continue;
3086 }
3087
3088 if (data.salts_shown[salt_pos] == 1)
3089 {
3090 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3091
3092 continue;
3093 }
3094
3095 // initialize amplifiers
3096
3097 if (data.attack_mode == ATTACK_MODE_COMBI)
3098 {
3099 uint i = 0;
3100
3101 while (i < innerloop_left)
3102 {
3103 if (feof (combs_fp)) break;
3104
3105 int line_len = fgetl (combs_fp, line_buf);
3106
3107 if (line_len >= PW_MAX1) continue;
3108
3109 line_len = convert_from_hex (line_buf, line_len);
3110
3111 char *line_buf_new = line_buf;
3112
3113 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3114 {
3115 char rule_buf_out[BLOCK_SIZE] = { 0 };
3116
3117 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3118
3119 if (rule_len_out < 0)
3120 {
3121 data.words_progress_rejected[salt_pos] += pws_cnt;
3122
3123 continue;
3124 }
3125
3126 line_len = rule_len_out;
3127
3128 line_buf_new = rule_buf_out;
3129 }
3130
3131 line_len = MIN (line_len, PW_DICTMAX);
3132
3133 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3134
3135 memcpy (ptr, line_buf_new, line_len);
3136
3137 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3138
3139 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3140 {
3141 uppercase (ptr, line_len);
3142 }
3143
3144 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3145 {
3146 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3147 {
3148 ptr[line_len] = 0x80;
3149 }
3150
3151 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3152 {
3153 ptr[line_len] = 0x01;
3154 }
3155 }
3156
3157 device_param->combs_buf[i].pw_len = line_len;
3158
3159 i++;
3160 }
3161
3162 for (uint j = i; j < innerloop_left; j++)
3163 {
3164 device_param->combs_buf[j].i[0] = 0;
3165 device_param->combs_buf[j].i[1] = 0;
3166 device_param->combs_buf[j].i[2] = 0;
3167 device_param->combs_buf[j].i[3] = 0;
3168 device_param->combs_buf[j].i[4] = 0;
3169 device_param->combs_buf[j].i[5] = 0;
3170 device_param->combs_buf[j].i[6] = 0;
3171 device_param->combs_buf[j].i[7] = 0;
3172
3173 device_param->combs_buf[j].pw_len = 0;
3174 }
3175
3176 innerloop_left = i;
3177 }
3178 else if (data.attack_mode == ATTACK_MODE_BF)
3179 {
3180 u64 off = innerloop_pos;
3181
3182 device_param->kernel_params_mp_r_buf64[3] = off;
3183
3184 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3185 }
3186 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3187 {
3188 u64 off = innerloop_pos;
3189
3190 device_param->kernel_params_mp_buf64[3] = off;
3191
3192 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3193 }
3194 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3195 {
3196 u64 off = innerloop_pos;
3197
3198 device_param->kernel_params_mp_buf64[3] = off;
3199
3200 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3201 }
3202
3203 // copy amplifiers
3204
3205 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3206 {
3207 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);
3208 }
3209 else if (data.attack_mode == ATTACK_MODE_COMBI)
3210 {
3211 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);
3212 }
3213 else if (data.attack_mode == ATTACK_MODE_BF)
3214 {
3215 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);
3216 }
3217 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3218 {
3219 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);
3220 }
3221 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3222 {
3223 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);
3224 }
3225
3226 if (data.benchmark == 1)
3227 {
3228 hc_timer_set (&device_param->timer_speed);
3229 }
3230
3231 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3232
3233 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3234
3235 if (data.devices_status == STATUS_CRACKED) break;
3236 if (data.devices_status == STATUS_ABORTED) break;
3237 if (data.devices_status == STATUS_QUIT) break;
3238
3239 /**
3240 * result
3241 */
3242
3243 hc_thread_mutex_lock (mux_display);
3244
3245 check_cracked (device_param, salt_pos);
3246
3247 hc_thread_mutex_unlock (mux_display);
3248
3249 /**
3250 * progress
3251 */
3252
3253 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3254
3255 hc_thread_mutex_lock (mux_counter);
3256
3257 data.words_progress_done[salt_pos] += perf_sum_all;
3258
3259 hc_thread_mutex_unlock (mux_counter);
3260
3261 /**
3262 * speed
3263 */
3264
3265 double speed_ms;
3266
3267 hc_timer_get (device_param->timer_speed, speed_ms);
3268
3269 hc_timer_set (&device_param->timer_speed);
3270
3271 hc_thread_mutex_lock (mux_display);
3272
3273 // current speed
3274
3275 device_param->speed_cnt[speed_pos] = perf_sum_all;
3276
3277 device_param->speed_ms[speed_pos] = speed_ms;
3278
3279 hc_thread_mutex_unlock (mux_display);
3280
3281 speed_pos++;
3282
3283 if (speed_pos == SPEED_CACHE)
3284 {
3285 speed_pos = 0;
3286 }
3287
3288 /**
3289 * benchmark
3290 */
3291
3292 if (data.benchmark == 1) break;
3293 }
3294 }
3295
3296 device_param->speed_pos = speed_pos;
3297
3298 myfree (line_buf);
3299 }
3300
3301 static void load_segment (wl_data_t *wl_data, FILE *fd)
3302 {
3303 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3304
3305 wl_data->pos = 0;
3306
3307 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3308
3309 wl_data->buf[wl_data->cnt] = 0;
3310
3311 if (wl_data->cnt == 0) return;
3312
3313 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3314
3315 while (!feof (fd))
3316 {
3317 if (wl_data->cnt == wl_data->avail)
3318 {
3319 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3320
3321 wl_data->avail += wl_data->incr;
3322 }
3323
3324 const int c = fgetc (fd);
3325
3326 if (c == EOF) break;
3327
3328 wl_data->buf[wl_data->cnt] = (char) c;
3329
3330 wl_data->cnt++;
3331
3332 if (c == '\n') break;
3333 }
3334
3335 // ensure stream ends with a newline
3336
3337 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3338 {
3339 wl_data->cnt++;
3340
3341 wl_data->buf[wl_data->cnt - 1] = '\n';
3342 }
3343
3344 return;
3345 }
3346
3347 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3348 {
3349 char *ptr = buf;
3350
3351 for (u32 i = 0; i < sz; i++, ptr++)
3352 {
3353 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3354
3355 if (i == 7)
3356 {
3357 *off = i;
3358 *len = i;
3359
3360 return;
3361 }
3362
3363 if (*ptr != '\n') continue;
3364
3365 *off = i + 1;
3366
3367 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3368
3369 *len = i;
3370
3371 return;
3372 }
3373
3374 *off = sz;
3375 *len = sz;
3376 }
3377
3378 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3379 {
3380 char *ptr = buf;
3381
3382 for (u32 i = 0; i < sz; i++, ptr++)
3383 {
3384 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3385
3386 if (*ptr != '\n') continue;
3387
3388 *off = i + 1;
3389
3390 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3391
3392 *len = i;
3393
3394 return;
3395 }
3396
3397 *off = sz;
3398 *len = sz;
3399 }
3400
3401 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3402 {
3403 char *ptr = buf;
3404
3405 for (u32 i = 0; i < sz; i++, ptr++)
3406 {
3407 if (*ptr != '\n') continue;
3408
3409 *off = i + 1;
3410
3411 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3412
3413 *len = i;
3414
3415 return;
3416 }
3417
3418 *off = sz;
3419 *len = sz;
3420 }
3421
3422 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3423 {
3424 while (wl_data->pos < wl_data->cnt)
3425 {
3426 uint off;
3427 uint len;
3428
3429 char *ptr = wl_data->buf + wl_data->pos;
3430
3431 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3432
3433 wl_data->pos += off;
3434
3435 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3436 {
3437 char rule_buf_out[BLOCK_SIZE] = { 0 };
3438
3439 int rule_len_out = -1;
3440
3441 if (len < BLOCK_SIZE)
3442 {
3443 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3444 }
3445
3446 if (rule_len_out < 0)
3447 {
3448 continue;
3449 }
3450
3451 if (rule_len_out > PW_MAX)
3452 {
3453 continue;
3454 }
3455 }
3456 else
3457 {
3458 if (len > PW_MAX)
3459 {
3460 continue;
3461 }
3462 }
3463
3464 *out_buf = ptr;
3465 *out_len = len;
3466
3467 return;
3468 }
3469
3470 if (feof (fd))
3471 {
3472 fprintf (stderr, "BUG feof()!!\n");
3473
3474 return;
3475 }
3476
3477 load_segment (wl_data, fd);
3478
3479 get_next_word (wl_data, fd, out_buf, out_len);
3480 }
3481
3482 #ifdef _POSIX
3483 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3484 #endif
3485
3486 #ifdef _WIN
3487 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3488 #endif
3489 {
3490 hc_signal (NULL);
3491
3492 dictstat_t d;
3493
3494 d.cnt = 0;
3495
3496 #ifdef _POSIX
3497 fstat (fileno (fd), &d.stat);
3498 #endif
3499
3500 #ifdef _WIN
3501 _fstat64 (fileno (fd), &d.stat);
3502 #endif
3503
3504 d.stat.st_mode = 0;
3505 d.stat.st_nlink = 0;
3506 d.stat.st_uid = 0;
3507 d.stat.st_gid = 0;
3508 d.stat.st_rdev = 0;
3509 d.stat.st_atime = 0;
3510
3511 #ifdef _POSIX
3512 d.stat.st_blksize = 0;
3513 d.stat.st_blocks = 0;
3514 #endif
3515
3516 if (d.stat.st_size == 0) return 0;
3517
3518 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3519
3520 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3521 {
3522 if (d_cache)
3523 {
3524 u64 cnt = d_cache->cnt;
3525
3526 u64 keyspace = cnt;
3527
3528 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3529 {
3530 keyspace *= data.kernel_rules_cnt;
3531 }
3532 else if (data.attack_kern == ATTACK_KERN_COMBI)
3533 {
3534 keyspace *= data.combs_cnt;
3535 }
3536
3537 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);
3538 if (data.quiet == 0) log_info ("");
3539
3540 hc_signal (sigHandler_default);
3541
3542 return (keyspace);
3543 }
3544 }
3545
3546 time_t now = 0;
3547 time_t prev = 0;
3548
3549 u64 comp = 0;
3550 u64 cnt = 0;
3551 u64 cnt2 = 0;
3552
3553 while (!feof (fd))
3554 {
3555 load_segment (wl_data, fd);
3556
3557 comp += wl_data->cnt;
3558
3559 u32 i = 0;
3560
3561 while (i < wl_data->cnt)
3562 {
3563 u32 len;
3564 u32 off;
3565
3566 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3567
3568 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3569 {
3570 char rule_buf_out[BLOCK_SIZE] = { 0 };
3571
3572 int rule_len_out = -1;
3573
3574 if (len < BLOCK_SIZE)
3575 {
3576 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3577 }
3578
3579 if (rule_len_out < 0)
3580 {
3581 len = PW_MAX1;
3582 }
3583 else
3584 {
3585 len = rule_len_out;
3586 }
3587 }
3588
3589 if (len < PW_MAX1)
3590 {
3591 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3592 {
3593 cnt += data.kernel_rules_cnt;
3594 }
3595 else if (data.attack_kern == ATTACK_KERN_COMBI)
3596 {
3597 cnt += data.combs_cnt;
3598 }
3599
3600 d.cnt++;
3601 }
3602
3603 i += off;
3604
3605 cnt2++;
3606 }
3607
3608 time (&now);
3609
3610 if ((now - prev) == 0) continue;
3611
3612 float percent = (float) comp / (float) d.stat.st_size;
3613
3614 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);
3615
3616 time (&prev);
3617 }
3618
3619 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);
3620 if (data.quiet == 0) log_info ("");
3621
3622 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3623
3624 hc_signal (sigHandler_default);
3625
3626 return (cnt);
3627 }
3628
3629 static void *thread_monitor (void *p)
3630 {
3631 uint runtime_check = 0;
3632 uint remove_check = 0;
3633 uint status_check = 0;
3634 uint restore_check = 0;
3635
3636 uint restore_left = data.restore_timer;
3637 uint remove_left = data.remove_timer;
3638 uint status_left = data.status_timer;
3639
3640 #ifdef HAVE_HWMON
3641 uint hwmon_check = 0;
3642
3643 // these variables are mainly used for fan control (AMD only)
3644
3645 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3646
3647 // temperature controller "loopback" values
3648
3649 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3650 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3651
3652 #ifdef HAVE_ADL
3653 int temp_threshold = 1; // degrees celcius
3654
3655 int fan_speed_min = 15; // in percentage
3656 int fan_speed_max = 100;
3657 #endif // HAVE_ADL
3658
3659 time_t last_temp_check_time;
3660 #endif // HAVE_HWMON
3661
3662 uint sleep_time = 1;
3663
3664 if (data.runtime)
3665 {
3666 runtime_check = 1;
3667 }
3668
3669 if (data.restore_timer)
3670 {
3671 restore_check = 1;
3672 }
3673
3674 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3675 {
3676 remove_check = 1;
3677 }
3678
3679 if (data.status == 1)
3680 {
3681 status_check = 1;
3682 }
3683
3684 #ifdef HAVE_HWMON
3685 if (data.gpu_temp_disable == 0)
3686 {
3687 time (&last_temp_check_time);
3688
3689 hwmon_check = 1;
3690 }
3691 #endif
3692
3693 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3694 {
3695 #ifdef HAVE_HWMON
3696 if (hwmon_check == 0)
3697 #endif
3698 return (p);
3699 }
3700
3701 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3702 {
3703 hc_sleep (sleep_time);
3704
3705 if (data.devices_status != STATUS_RUNNING) continue;
3706
3707 #ifdef HAVE_HWMON
3708 if (hwmon_check == 1)
3709 {
3710 hc_thread_mutex_lock (mux_adl);
3711
3712 time_t temp_check_time;
3713
3714 time (&temp_check_time);
3715
3716 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3717
3718 if (Ta == 0) Ta = 1;
3719
3720 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3721 {
3722 hc_device_param_t *device_param = &data.devices_param[device_id];
3723
3724 if (device_param->skipped) continue;
3725
3726 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3727
3728 const int temperature = hm_get_temperature_with_device_id (device_id);
3729
3730 if (temperature > (int) data.gpu_temp_abort)
3731 {
3732 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3733
3734 if (data.devices_status != STATUS_QUIT) myabort ();
3735
3736 break;
3737 }
3738
3739 #ifdef HAVE_ADL
3740 const int gpu_temp_retain = data.gpu_temp_retain;
3741
3742 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3743 {
3744 if (data.hm_device[device_id].fan_supported == 1)
3745 {
3746 int temp_cur = temperature;
3747
3748 int temp_diff_new = gpu_temp_retain - temp_cur;
3749
3750 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3751
3752 // calculate Ta value (time difference in seconds between the last check and this check)
3753
3754 last_temp_check_time = temp_check_time;
3755
3756 float Kp = 1.8;
3757 float Ki = 0.005;
3758 float Kd = 6;
3759
3760 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3761
3762 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);
3763
3764 if (abs (fan_diff_required) >= temp_threshold)
3765 {
3766 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3767
3768 int fan_speed_level = fan_speed_cur;
3769
3770 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3771
3772 int fan_speed_new = fan_speed_level - fan_diff_required;
3773
3774 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3775 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3776
3777 if (fan_speed_new != fan_speed_cur)
3778 {
3779 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3780 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3781
3782 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3783 {
3784 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3785
3786 fan_speed_chgd[device_id] = 1;
3787 }
3788
3789 temp_diff_old[device_id] = temp_diff_new;
3790 }
3791 }
3792 }
3793 }
3794 #endif // HAVE_ADL
3795 }
3796
3797 hc_thread_mutex_unlock (mux_adl);
3798 }
3799 #endif // HAVE_HWMON
3800
3801 if (restore_check == 1)
3802 {
3803 restore_left--;
3804
3805 if (restore_left == 0)
3806 {
3807 if (data.restore_disable == 0) cycle_restore ();
3808
3809 restore_left = data.restore_timer;
3810 }
3811 }
3812
3813 if ((runtime_check == 1) && (data.runtime_start > 0))
3814 {
3815 time_t runtime_cur;
3816
3817 time (&runtime_cur);
3818
3819 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3820
3821 if (runtime_left <= 0)
3822 {
3823 if (data.benchmark == 0)
3824 {
3825 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3826 }
3827
3828 if (data.devices_status != STATUS_QUIT) myabort ();
3829 }
3830 }
3831
3832 if (remove_check == 1)
3833 {
3834 remove_left--;
3835
3836 if (remove_left == 0)
3837 {
3838 if (data.digests_saved != data.digests_done)
3839 {
3840 data.digests_saved = data.digests_done;
3841
3842 save_hash ();
3843 }
3844
3845 remove_left = data.remove_timer;
3846 }
3847 }
3848
3849 if (status_check == 1)
3850 {
3851 status_left--;
3852
3853 if (status_left == 0)
3854 {
3855 hc_thread_mutex_lock (mux_display);
3856
3857 if (data.quiet == 0) clear_prompt ();
3858
3859 if (data.quiet == 0) log_info ("");
3860
3861 status_display ();
3862
3863 if (data.quiet == 0) log_info ("");
3864
3865 hc_thread_mutex_unlock (mux_display);
3866
3867 status_left = data.status_timer;
3868 }
3869 }
3870 }
3871
3872 #ifdef HAVE_HWMON
3873 myfree (fan_speed_chgd);
3874
3875 myfree (temp_diff_old);
3876 myfree (temp_diff_sum);
3877 #endif
3878
3879 p = NULL;
3880
3881 return (p);
3882 }
3883
3884 static void *thread_outfile_remove (void *p)
3885 {
3886 // some hash-dependent constants
3887 char *outfile_dir = data.outfile_check_directory;
3888 uint dgst_size = data.dgst_size;
3889 uint isSalted = data.isSalted;
3890 uint esalt_size = data.esalt_size;
3891 uint hash_mode = data.hash_mode;
3892
3893 uint outfile_check_timer = data.outfile_check_timer;
3894
3895 char separator = data.separator;
3896
3897 // some hash-dependent functions
3898 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3899 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3900
3901 // buffers
3902 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3903
3904 hash_buf.digest = mymalloc (dgst_size);
3905
3906 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3907
3908 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3909
3910 uint digest_buf[64] = { 0 };
3911
3912 outfile_data_t *out_info = NULL;
3913
3914 char **out_files = NULL;
3915
3916 time_t folder_mtime = 0;
3917
3918 int out_cnt = 0;
3919
3920 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3921
3922 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3923 {
3924 hc_sleep (1);
3925
3926 if (data.devices_status != STATUS_RUNNING) continue;
3927
3928 check_left--;
3929
3930 if (check_left == 0)
3931 {
3932 struct stat outfile_check_stat;
3933
3934 if (stat (outfile_dir, &outfile_check_stat) == 0)
3935 {
3936 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3937
3938 if (is_dir == 1)
3939 {
3940 if (outfile_check_stat.st_mtime > folder_mtime)
3941 {
3942 char **out_files_new = scan_directory (outfile_dir);
3943
3944 int out_cnt_new = count_dictionaries (out_files_new);
3945
3946 outfile_data_t *out_info_new = NULL;
3947
3948 if (out_cnt_new > 0)
3949 {
3950 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3951
3952 for (int i = 0; i < out_cnt_new; i++)
3953 {
3954 out_info_new[i].file_name = out_files_new[i];
3955
3956 // check if there are files that we have seen/checked before (and not changed)
3957
3958 for (int j = 0; j < out_cnt; j++)
3959 {
3960 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3961 {
3962 struct stat outfile_stat;
3963
3964 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3965 {
3966 if (outfile_stat.st_ctime == out_info[j].ctime)
3967 {
3968 out_info_new[i].ctime = out_info[j].ctime;
3969 out_info_new[i].seek = out_info[j].seek;
3970 }
3971 }
3972 }
3973 }
3974 }
3975 }
3976
3977 local_free (out_info);
3978 local_free (out_files);
3979
3980 out_files = out_files_new;
3981 out_cnt = out_cnt_new;
3982 out_info = out_info_new;
3983
3984 folder_mtime = outfile_check_stat.st_mtime;
3985 }
3986
3987 for (int j = 0; j < out_cnt; j++)
3988 {
3989 FILE *fp = fopen (out_info[j].file_name, "rb");
3990
3991 if (fp != NULL)
3992 {
3993 //hc_thread_mutex_lock (mux_display);
3994
3995 #ifdef _POSIX
3996 struct stat outfile_stat;
3997
3998 fstat (fileno (fp), &outfile_stat);
3999 #endif
4000
4001 #ifdef _WIN
4002 struct stat64 outfile_stat;
4003
4004 _fstat64 (fileno (fp), &outfile_stat);
4005 #endif
4006
4007 if (outfile_stat.st_ctime > out_info[j].ctime)
4008 {
4009 out_info[j].ctime = outfile_stat.st_ctime;
4010 out_info[j].seek = 0;
4011 }
4012
4013 fseek (fp, out_info[j].seek, SEEK_SET);
4014
4015 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4016
4017 while (!feof (fp))
4018 {
4019 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4020
4021 if (ptr == NULL) break;
4022
4023 int line_len = strlen (line_buf);
4024
4025 if (line_len <= 0) continue;
4026
4027 int iter = MAX_CUT_TRIES;
4028
4029 for (uint i = line_len - 1; i && iter; i--, line_len--)
4030 {
4031 if (line_buf[i] != separator) continue;
4032
4033 int parser_status = PARSER_OK;
4034
4035 if ((hash_mode != 2500) && (hash_mode != 6800))
4036 {
4037 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4038 }
4039
4040 uint found = 0;
4041
4042 if (parser_status == PARSER_OK)
4043 {
4044 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4045 {
4046 if (data.salts_shown[salt_pos] == 1) continue;
4047
4048 salt_t *salt_buf = &data.salts_buf[salt_pos];
4049
4050 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4051 {
4052 uint idx = salt_buf->digests_offset + digest_pos;
4053
4054 if (data.digests_shown[idx] == 1) continue;
4055
4056 uint cracked = 0;
4057
4058 if (hash_mode == 6800)
4059 {
4060 if (i == salt_buf->salt_len)
4061 {
4062 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4063 }
4064 }
4065 else if (hash_mode == 2500)
4066 {
4067 // BSSID : MAC1 : MAC2 (:plain)
4068 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4069 {
4070 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4071
4072 if (!cracked) continue;
4073
4074 // now compare MAC1 and MAC2 too, since we have this additional info
4075 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4076 char *mac2_pos = mac1_pos + 12 + 1;
4077
4078 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4079 wpa_t *wpa = &wpas[salt_pos];
4080
4081 // compare hex string(s) vs binary MAC address(es)
4082
4083 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4084 {
4085 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4086 {
4087 cracked = 0;
4088
4089 break;
4090 }
4091 }
4092
4093 // early skip ;)
4094 if (!cracked) continue;
4095
4096 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4097 {
4098 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4099 {
4100 cracked = 0;
4101
4102 break;
4103 }
4104 }
4105 }
4106 }
4107 else
4108 {
4109 char *digests_buf_ptr = (char *) data.digests_buf;
4110
4111 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4112
4113 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4114 }
4115
4116 if (cracked == 1)
4117 {
4118 found = 1;
4119
4120 data.digests_shown[idx] = 1;
4121
4122 data.digests_done++;
4123
4124 salt_buf->digests_done++;
4125
4126 if (salt_buf->digests_done == salt_buf->digests_cnt)
4127 {
4128 data.salts_shown[salt_pos] = 1;
4129
4130 data.salts_done++;
4131
4132 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4133 }
4134 }
4135 }
4136
4137 if (data.devices_status == STATUS_CRACKED) break;
4138 }
4139 }
4140
4141 if (found) break;
4142
4143 if (data.devices_status == STATUS_CRACKED) break;
4144
4145 iter--;
4146 }
4147
4148 if (data.devices_status == STATUS_CRACKED) break;
4149 }
4150
4151 myfree (line_buf);
4152
4153 out_info[j].seek = ftell (fp);
4154
4155 //hc_thread_mutex_unlock (mux_display);
4156
4157 fclose (fp);
4158 }
4159 }
4160 }
4161 }
4162
4163 check_left = outfile_check_timer;
4164 }
4165 }
4166
4167 if (esalt_size) local_free (hash_buf.esalt);
4168
4169 if (isSalted) local_free (hash_buf.salt);
4170
4171 local_free (hash_buf.digest);
4172
4173 local_free (out_info);
4174
4175 local_free (out_files);
4176
4177 p = NULL;
4178
4179 return (p);
4180 }
4181
4182 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4183 {
4184 if (device_param->pws_cnt < device_param->kernel_power)
4185 {
4186 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4187
4188 u8 *ptr = (u8 *) pw->i;
4189
4190 memcpy (ptr, pw_buf, pw_len);
4191
4192 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4193
4194 pw->pw_len = pw_len;
4195
4196 device_param->pws_cnt++;
4197 }
4198 else
4199 {
4200 fprintf (stderr, "BUG pw_add()!!\n");
4201
4202 return;
4203 }
4204 }
4205
4206 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4207 {
4208 hc_thread_mutex_lock (mux_dispatcher);
4209
4210 const u64 words_cur = data.words_cur;
4211 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4212
4213 device_param->words_off = words_cur;
4214
4215 const u64 words_left = words_base - words_cur;
4216
4217 if (allow_div)
4218 {
4219 if (data.kernel_power_all > words_left)
4220 {
4221 if (data.kernel_power_div == 0)
4222 {
4223 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4224 }
4225 }
4226
4227 if (data.kernel_power_div)
4228 {
4229 if (device_param->kernel_power == device_param->kernel_power_user)
4230 {
4231 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4232
4233 if (kernel_power_new < device_param->kernel_power)
4234 {
4235 device_param->kernel_power = kernel_power_new;
4236 }
4237 }
4238 }
4239 }
4240
4241 const uint kernel_power = device_param->kernel_power;
4242
4243 uint work = MIN (words_left, kernel_power);
4244
4245 work = MIN (work, max);
4246
4247 data.words_cur += work;
4248
4249 hc_thread_mutex_unlock (mux_dispatcher);
4250
4251 return work;
4252 }
4253
4254 static void *thread_calc_stdin (void *p)
4255 {
4256 hc_device_param_t *device_param = (hc_device_param_t *) p;
4257
4258 if (device_param->skipped) return NULL;
4259
4260 autotune (device_param);
4261
4262 char *buf = (char *) mymalloc (HCBUFSIZ);
4263
4264 const uint attack_kern = data.attack_kern;
4265
4266 const uint kernel_power = device_param->kernel_power;
4267
4268 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4269 {
4270 hc_thread_mutex_lock (mux_dispatcher);
4271
4272 if (feof (stdin) != 0)
4273 {
4274 hc_thread_mutex_unlock (mux_dispatcher);
4275
4276 break;
4277 }
4278
4279 uint words_cur = 0;
4280
4281 while (words_cur < kernel_power)
4282 {
4283 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4284
4285 if (line_buf == NULL) break;
4286
4287 uint line_len = in_superchop (line_buf);
4288
4289 line_len = convert_from_hex (line_buf, line_len);
4290
4291 // post-process rule engine
4292
4293 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4294 {
4295 char rule_buf_out[BLOCK_SIZE] = { 0 };
4296
4297 int rule_len_out = -1;
4298
4299 if (line_len < BLOCK_SIZE)
4300 {
4301 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4302 }
4303
4304 if (rule_len_out < 0) continue;
4305
4306 line_buf = rule_buf_out;
4307 line_len = rule_len_out;
4308 }
4309
4310 if (line_len > PW_MAX)
4311 {
4312 continue;
4313 }
4314
4315 if (attack_kern == ATTACK_KERN_STRAIGHT)
4316 {
4317 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4318 {
4319 hc_thread_mutex_lock (mux_counter);
4320
4321 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4322 {
4323 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4324 }
4325
4326 hc_thread_mutex_unlock (mux_counter);
4327
4328 continue;
4329 }
4330 }
4331 else if (attack_kern == ATTACK_KERN_COMBI)
4332 {
4333 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4334 // since we still need to combine the plains
4335
4336 if (line_len > data.pw_max)
4337 {
4338 hc_thread_mutex_lock (mux_counter);
4339
4340 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4341 {
4342 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4343 }
4344
4345 hc_thread_mutex_unlock (mux_counter);
4346
4347 continue;
4348 }
4349 }
4350
4351 pw_add (device_param, (u8 *) line_buf, line_len);
4352
4353 words_cur++;
4354
4355 if (data.devices_status == STATUS_CRACKED) break;
4356 if (data.devices_status == STATUS_ABORTED) break;
4357 if (data.devices_status == STATUS_QUIT) break;
4358 if (data.devices_status == STATUS_BYPASS) break;
4359 }
4360
4361 hc_thread_mutex_unlock (mux_dispatcher);
4362
4363 if (data.devices_status == STATUS_CRACKED) break;
4364 if (data.devices_status == STATUS_ABORTED) break;
4365 if (data.devices_status == STATUS_QUIT) break;
4366 if (data.devices_status == STATUS_BYPASS) break;
4367
4368 // flush
4369
4370 const uint pws_cnt = device_param->pws_cnt;
4371
4372 if (pws_cnt)
4373 {
4374 run_copy (device_param, pws_cnt);
4375
4376 run_cracker (device_param, pws_cnt);
4377
4378 device_param->pws_cnt = 0;
4379
4380 if (attack_kern == ATTACK_KERN_STRAIGHT)
4381 {
4382 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4383 }
4384 else if (attack_kern == ATTACK_KERN_COMBI)
4385 {
4386 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4387 }
4388 }
4389 }
4390
4391 device_param->kernel_accel = 0;
4392 device_param->kernel_loops = 0;
4393
4394 myfree (buf);
4395
4396 return NULL;
4397 }
4398
4399 static void *thread_calc (void *p)
4400 {
4401 hc_device_param_t *device_param = (hc_device_param_t *) p;
4402
4403 if (device_param->skipped) return NULL;
4404
4405 autotune (device_param);
4406
4407 const uint attack_mode = data.attack_mode;
4408 const uint attack_kern = data.attack_kern;
4409
4410 if (attack_mode == ATTACK_MODE_BF)
4411 {
4412 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4413 {
4414 const uint work = get_work (device_param, -1, true);
4415
4416 if (work == 0) break;
4417
4418 const u64 words_off = device_param->words_off;
4419 const u64 words_fin = words_off + work;
4420
4421 const uint pws_cnt = work;
4422
4423 device_param->pws_cnt = pws_cnt;
4424
4425 if (pws_cnt)
4426 {
4427 run_copy (device_param, pws_cnt);
4428
4429 run_cracker (device_param, pws_cnt);
4430
4431 device_param->pws_cnt = 0;
4432
4433 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4434 }
4435
4436 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4437
4438 if (data.devices_status == STATUS_CRACKED) break;
4439 if (data.devices_status == STATUS_ABORTED) break;
4440 if (data.devices_status == STATUS_QUIT) break;
4441 if (data.devices_status == STATUS_BYPASS) break;
4442
4443 if (data.benchmark == 1) break;
4444
4445 device_param->words_done = words_fin;
4446 }
4447 }
4448 else
4449 {
4450 const uint segment_size = data.segment_size;
4451
4452 char *dictfile = data.dictfile;
4453
4454 if (attack_mode == ATTACK_MODE_COMBI)
4455 {
4456 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4457 {
4458 dictfile = data.dictfile2;
4459 }
4460 }
4461
4462 FILE *fd = fopen (dictfile, "rb");
4463
4464 if (fd == NULL)
4465 {
4466 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4467
4468 return NULL;
4469 }
4470
4471 if (attack_mode == ATTACK_MODE_COMBI)
4472 {
4473 const uint combs_mode = data.combs_mode;
4474
4475 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4476 {
4477 const char *dictfilec = data.dictfile2;
4478
4479 FILE *combs_fp = fopen (dictfilec, "rb");
4480
4481 if (combs_fp == NULL)
4482 {
4483 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4484
4485 fclose (fd);
4486
4487 return NULL;
4488 }
4489
4490 device_param->combs_fp = combs_fp;
4491 }
4492 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4493 {
4494 const char *dictfilec = data.dictfile;
4495
4496 FILE *combs_fp = fopen (dictfilec, "rb");
4497
4498 if (combs_fp == NULL)
4499 {
4500 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4501
4502 fclose (fd);
4503
4504 return NULL;
4505 }
4506
4507 device_param->combs_fp = combs_fp;
4508 }
4509 }
4510
4511 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4512
4513 wl_data->buf = (char *) mymalloc (segment_size);
4514 wl_data->avail = segment_size;
4515 wl_data->incr = segment_size;
4516 wl_data->cnt = 0;
4517 wl_data->pos = 0;
4518
4519 u64 words_cur = 0;
4520
4521 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4522 {
4523 u64 words_off = 0;
4524 u64 words_fin = 0;
4525
4526 bool allow_div = true;
4527
4528 u64 max = -1;
4529
4530 while (max)
4531 {
4532 const uint work = get_work (device_param, max, allow_div);
4533
4534 allow_div = false;
4535
4536 if (work == 0) break;
4537
4538 words_off = device_param->words_off;
4539 words_fin = words_off + work;
4540
4541 char *line_buf;
4542 uint line_len;
4543
4544 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4545
4546 max = 0;
4547
4548 for ( ; words_cur < words_fin; words_cur++)
4549 {
4550 get_next_word (wl_data, fd, &line_buf, &line_len);
4551
4552 line_len = convert_from_hex (line_buf, line_len);
4553
4554 // post-process rule engine
4555
4556 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4557 {
4558 char rule_buf_out[BLOCK_SIZE] = { 0 };
4559
4560 int rule_len_out = -1;
4561
4562 if (line_len < BLOCK_SIZE)
4563 {
4564 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4565 }
4566
4567 if (rule_len_out < 0) continue;
4568
4569 line_buf = rule_buf_out;
4570 line_len = rule_len_out;
4571 }
4572
4573 if (attack_kern == ATTACK_KERN_STRAIGHT)
4574 {
4575 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4576 {
4577 max++;
4578
4579 hc_thread_mutex_lock (mux_counter);
4580
4581 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4582 {
4583 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4584 }
4585
4586 hc_thread_mutex_unlock (mux_counter);
4587
4588 continue;
4589 }
4590 }
4591 else if (attack_kern == ATTACK_KERN_COMBI)
4592 {
4593 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4594 // since we still need to combine the plains
4595
4596 if (line_len > data.pw_max)
4597 {
4598 max++;
4599
4600 hc_thread_mutex_lock (mux_counter);
4601
4602 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4603 {
4604 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4605 }
4606
4607 hc_thread_mutex_unlock (mux_counter);
4608
4609 continue;
4610 }
4611 }
4612
4613 pw_add (device_param, (u8 *) line_buf, line_len);
4614
4615 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4616
4617 if (data.devices_status == STATUS_CRACKED) break;
4618 if (data.devices_status == STATUS_ABORTED) break;
4619 if (data.devices_status == STATUS_QUIT) break;
4620 if (data.devices_status == STATUS_BYPASS) break;
4621 }
4622
4623 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4624
4625 if (data.devices_status == STATUS_CRACKED) break;
4626 if (data.devices_status == STATUS_ABORTED) break;
4627 if (data.devices_status == STATUS_QUIT) break;
4628 if (data.devices_status == STATUS_BYPASS) break;
4629 }
4630
4631 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4632
4633 if (data.devices_status == STATUS_CRACKED) break;
4634 if (data.devices_status == STATUS_ABORTED) break;
4635 if (data.devices_status == STATUS_QUIT) break;
4636 if (data.devices_status == STATUS_BYPASS) break;
4637
4638 //
4639 // flush
4640 //
4641
4642 const uint pws_cnt = device_param->pws_cnt;
4643
4644 if (pws_cnt)
4645 {
4646 run_copy (device_param, pws_cnt);
4647
4648 run_cracker (device_param, pws_cnt);
4649
4650 device_param->pws_cnt = 0;
4651
4652 if (attack_kern == ATTACK_KERN_STRAIGHT)
4653 {
4654 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4655 }
4656 else if (attack_kern == ATTACK_KERN_COMBI)
4657 {
4658 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4659 }
4660 }
4661
4662 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4663
4664 if (data.devices_status == STATUS_CRACKED) break;
4665 if (data.devices_status == STATUS_ABORTED) break;
4666 if (data.devices_status == STATUS_QUIT) break;
4667 if (data.devices_status == STATUS_BYPASS) break;
4668
4669 if (words_fin == 0) break;
4670
4671 device_param->words_done = words_fin;
4672 }
4673
4674 if (attack_mode == ATTACK_MODE_COMBI)
4675 {
4676 fclose (device_param->combs_fp);
4677 }
4678
4679 free (wl_data->buf);
4680 free (wl_data);
4681
4682 fclose (fd);
4683 }
4684
4685 device_param->kernel_accel = 0;
4686 device_param->kernel_loops = 0;
4687
4688 return NULL;
4689 }
4690
4691 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4692 {
4693 if (!device_param)
4694 {
4695 log_error ("ERROR: %s : Invalid argument", __func__);
4696
4697 exit (-1);
4698 }
4699
4700 salt_t *salt_buf = &data.salts_buf[salt_pos];
4701
4702 device_param->kernel_params_buf32[24] = salt_pos;
4703 device_param->kernel_params_buf32[27] = 1;
4704 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4705 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4706 device_param->kernel_params_buf32[30] = 0;
4707 device_param->kernel_params_buf32[31] = 1;
4708
4709 char *dictfile_old = data.dictfile;
4710
4711 const char *weak_hash_check = "weak-hash-check";
4712
4713 data.dictfile = (char *) weak_hash_check;
4714
4715 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4716
4717 data.kernel_rules_buf[0].cmds[0] = 0;
4718
4719 /**
4720 * run the kernel
4721 */
4722
4723 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4724 {
4725 run_kernel (KERN_RUN_1, device_param, 1, false);
4726 }
4727 else
4728 {
4729 run_kernel (KERN_RUN_1, device_param, 1, false);
4730
4731 uint loop_step = 16;
4732
4733 const uint iter = salt_buf->salt_iter;
4734
4735 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4736 {
4737 uint loop_left = iter - loop_pos;
4738
4739 loop_left = MIN (loop_left, loop_step);
4740
4741 device_param->kernel_params_buf32[25] = loop_pos;
4742 device_param->kernel_params_buf32[26] = loop_left;
4743
4744 run_kernel (KERN_RUN_2, device_param, 1, false);
4745 }
4746
4747 run_kernel (KERN_RUN_3, device_param, 1, false);
4748 }
4749
4750 /**
4751 * result
4752 */
4753
4754 check_cracked (device_param, salt_pos);
4755
4756 /**
4757 * cleanup
4758 */
4759
4760 device_param->kernel_params_buf32[24] = 0;
4761 device_param->kernel_params_buf32[25] = 0;
4762 device_param->kernel_params_buf32[26] = 0;
4763 device_param->kernel_params_buf32[27] = 0;
4764 device_param->kernel_params_buf32[28] = 0;
4765 device_param->kernel_params_buf32[29] = 0;
4766 device_param->kernel_params_buf32[30] = 0;
4767 device_param->kernel_params_buf32[31] = 0;
4768
4769 data.dictfile = dictfile_old;
4770
4771 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4772 }
4773
4774 // hlfmt hashcat
4775
4776 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4777 {
4778 if (data.username == 0)
4779 {
4780 *hashbuf_pos = line_buf;
4781 *hashbuf_len = line_len;
4782 }
4783 else
4784 {
4785 char *pos = line_buf;
4786 int len = line_len;
4787
4788 for (int i = 0; i < line_len; i++, pos++, len--)
4789 {
4790 if (line_buf[i] == data.separator)
4791 {
4792 pos++;
4793
4794 len--;
4795
4796 break;
4797 }
4798 }
4799
4800 *hashbuf_pos = pos;
4801 *hashbuf_len = len;
4802 }
4803 }
4804
4805 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4806 {
4807 char *pos = NULL;
4808 int len = 0;
4809
4810 int sep_cnt = 0;
4811
4812 for (int i = 0; i < line_len; i++)
4813 {
4814 if (line_buf[i] == data.separator)
4815 {
4816 sep_cnt++;
4817
4818 continue;
4819 }
4820
4821 if (sep_cnt == 0)
4822 {
4823 if (pos == NULL) pos = line_buf + i;
4824
4825 len++;
4826 }
4827 }
4828
4829 *userbuf_pos = pos;
4830 *userbuf_len = len;
4831 }
4832
4833 // hlfmt pwdump
4834
4835 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4836 {
4837 int sep_cnt = 0;
4838
4839 int sep2_len = 0;
4840 int sep3_len = 0;
4841
4842 for (int i = 0; i < line_len; i++)
4843 {
4844 if (line_buf[i] == ':')
4845 {
4846 sep_cnt++;
4847
4848 continue;
4849 }
4850
4851 if (sep_cnt == 2) sep2_len++;
4852 if (sep_cnt == 3) sep3_len++;
4853 }
4854
4855 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4856
4857 return 0;
4858 }
4859
4860 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4861 {
4862 char *pos = NULL;
4863 int len = 0;
4864
4865 int sep_cnt = 0;
4866
4867 for (int i = 0; i < line_len; i++)
4868 {
4869 if (line_buf[i] == ':')
4870 {
4871 sep_cnt++;
4872
4873 continue;
4874 }
4875
4876 if (data.hash_mode == 1000)
4877 {
4878 if (sep_cnt == 3)
4879 {
4880 if (pos == NULL) pos = line_buf + i;
4881
4882 len++;
4883 }
4884 }
4885 else if (data.hash_mode == 3000)
4886 {
4887 if (sep_cnt == 2)
4888 {
4889 if (pos == NULL) pos = line_buf + i;
4890
4891 len++;
4892 }
4893 }
4894 }
4895
4896 *hashbuf_pos = pos;
4897 *hashbuf_len = len;
4898 }
4899
4900 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4901 {
4902 char *pos = NULL;
4903 int len = 0;
4904
4905 int sep_cnt = 0;
4906
4907 for (int i = 0; i < line_len; i++)
4908 {
4909 if (line_buf[i] == ':')
4910 {
4911 sep_cnt++;
4912
4913 continue;
4914 }
4915
4916 if (sep_cnt == 0)
4917 {
4918 if (pos == NULL) pos = line_buf + i;
4919
4920 len++;
4921 }
4922 }
4923
4924 *userbuf_pos = pos;
4925 *userbuf_len = len;
4926 }
4927
4928 // hlfmt passwd
4929
4930 static int hlfmt_detect_passwd (char *line_buf, int line_len)
4931 {
4932 int sep_cnt = 0;
4933
4934 char sep5_first = 0;
4935 char sep6_first = 0;
4936
4937 for (int i = 0; i < line_len; i++)
4938 {
4939 if (line_buf[i] == ':')
4940 {
4941 sep_cnt++;
4942
4943 continue;
4944 }
4945
4946 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4947 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4948 }
4949
4950 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4951
4952 return 0;
4953 }
4954
4955 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4956 {
4957 char *pos = NULL;
4958 int len = 0;
4959
4960 int sep_cnt = 0;
4961
4962 for (int i = 0; i < line_len; i++)
4963 {
4964 if (line_buf[i] == ':')
4965 {
4966 sep_cnt++;
4967
4968 continue;
4969 }
4970
4971 if (sep_cnt == 1)
4972 {
4973 if (pos == NULL) pos = line_buf + i;
4974
4975 len++;
4976 }
4977 }
4978
4979 *hashbuf_pos = pos;
4980 *hashbuf_len = len;
4981 }
4982
4983 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4984 {
4985 char *pos = NULL;
4986 int len = 0;
4987
4988 int sep_cnt = 0;
4989
4990 for (int i = 0; i < line_len; i++)
4991 {
4992 if (line_buf[i] == ':')
4993 {
4994 sep_cnt++;
4995
4996 continue;
4997 }
4998
4999 if (sep_cnt == 0)
5000 {
5001 if (pos == NULL) pos = line_buf + i;
5002
5003 len++;
5004 }
5005 }
5006
5007 *userbuf_pos = pos;
5008 *userbuf_len = len;
5009 }
5010
5011 // hlfmt shadow
5012
5013 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5014 {
5015 int sep_cnt = 0;
5016
5017 for (int i = 0; i < line_len; i++)
5018 {
5019 if (line_buf[i] == ':') sep_cnt++;
5020 }
5021
5022 if (sep_cnt == 8) return 1;
5023
5024 return 0;
5025 }
5026
5027 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5028 {
5029 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5030 }
5031
5032 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5033 {
5034 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5035 }
5036
5037 // hlfmt main
5038
5039 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5040 {
5041 switch (hashfile_format)
5042 {
5043 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5044 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5045 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5046 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5047 }
5048 }
5049
5050 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5051 {
5052 switch (hashfile_format)
5053 {
5054 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5055 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5056 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5057 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5058 }
5059 }
5060
5061 char *strhlfmt (const uint hashfile_format)
5062 {
5063 switch (hashfile_format)
5064 {
5065 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5066 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5067 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5068 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5069 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5070 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5071 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5072 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5073 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5074 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5075 }
5076
5077 return ((char *) "Unknown");
5078 }
5079
5080 static uint hlfmt_detect (FILE *fp, uint max_check)
5081 {
5082 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5083
5084 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5085 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5086
5087 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5088
5089 uint num_check = 0;
5090
5091 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5092
5093 while (!feof (fp))
5094 {
5095 int line_len = fgetl (fp, line_buf);
5096
5097 if (line_len == 0) continue;
5098
5099 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5100 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5101 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5102
5103 if (num_check == max_check) break;
5104
5105 num_check++;
5106 }
5107
5108 myfree (line_buf);
5109
5110 uint hashlist_format = HLFMT_HASHCAT;
5111
5112 for (int i = 1; i < HLFMTS_CNT; i++)
5113 {
5114 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5115
5116 hashlist_format = i;
5117 }
5118
5119 free (formats_cnt);
5120
5121 return hashlist_format;
5122 }
5123
5124 /**
5125 * some further helper function
5126 */
5127
5128 // wrapper around mymalloc for ADL
5129
5130 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5131 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5132 {
5133 return mymalloc (iSize);
5134 }
5135 #endif
5136
5137 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)
5138 {
5139 u64 collisions = 0;
5140
5141 const uint dgst_pos0 = data.dgst_pos0;
5142 const uint dgst_pos1 = data.dgst_pos1;
5143 const uint dgst_pos2 = data.dgst_pos2;
5144 const uint dgst_pos3 = data.dgst_pos3;
5145
5146 memset (bitmap_a, 0, bitmap_size);
5147 memset (bitmap_b, 0, bitmap_size);
5148 memset (bitmap_c, 0, bitmap_size);
5149 memset (bitmap_d, 0, bitmap_size);
5150
5151 for (uint i = 0; i < digests_cnt; i++)
5152 {
5153 uint *digest_ptr = (uint *) digests_buf_ptr;
5154
5155 digests_buf_ptr += dgst_size;
5156
5157 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5158 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5159 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5160 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5161
5162 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5163 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5164 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5165 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5166
5167 if (bitmap_a[idx0] & val0) collisions++;
5168 if (bitmap_b[idx1] & val1) collisions++;
5169 if (bitmap_c[idx2] & val2) collisions++;
5170 if (bitmap_d[idx3] & val3) collisions++;
5171
5172 bitmap_a[idx0] |= val0;
5173 bitmap_b[idx1] |= val1;
5174 bitmap_c[idx2] |= val2;
5175 bitmap_d[idx3] |= val3;
5176
5177 if (collisions >= collisions_max) return 0x7fffffff;
5178 }
5179
5180 return collisions;
5181 }
5182
5183 /**
5184 * main
5185 */
5186
5187 int main (int argc, char **argv)
5188 {
5189 /**
5190 * To help users a bit
5191 */
5192
5193 char *compute = getenv ("COMPUTE");
5194
5195 if (compute)
5196 {
5197 static char display[100];
5198
5199 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5200
5201 putenv (display);
5202 }
5203 else
5204 {
5205 if (getenv ("DISPLAY") == NULL)
5206 putenv ((char *) "DISPLAY=:0");
5207 }
5208
5209 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5210 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5211
5212 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5213 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5214
5215 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5216 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5217
5218 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5219 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5220
5221 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5222 putenv ((char *) "POCL_KERNEL_CACHE=0");
5223
5224 /**
5225 * Real init
5226 */
5227
5228 memset (&data, 0, sizeof (hc_global_data_t));
5229
5230 time_t proc_start;
5231
5232 time (&proc_start);
5233
5234 data.proc_start = proc_start;
5235
5236 int myargc = argc;
5237 char **myargv = argv;
5238
5239 hc_thread_mutex_init (mux_dispatcher);
5240 hc_thread_mutex_init (mux_counter);
5241 hc_thread_mutex_init (mux_display);
5242 hc_thread_mutex_init (mux_adl);
5243
5244 /**
5245 * commandline parameters
5246 */
5247
5248 uint usage = USAGE;
5249 uint version = VERSION;
5250 uint quiet = QUIET;
5251 uint benchmark = BENCHMARK;
5252 uint show = SHOW;
5253 uint left = LEFT;
5254 uint username = USERNAME;
5255 uint remove = REMOVE;
5256 uint remove_timer = REMOVE_TIMER;
5257 u64 skip = SKIP;
5258 u64 limit = LIMIT;
5259 uint keyspace = KEYSPACE;
5260 uint potfile_disable = POTFILE_DISABLE;
5261 char *potfile_path = NULL;
5262 uint debug_mode = DEBUG_MODE;
5263 char *debug_file = NULL;
5264 char *induction_dir = NULL;
5265 char *outfile_check_dir = NULL;
5266 uint force = FORCE;
5267 uint runtime = RUNTIME;
5268 uint hash_mode = HASH_MODE;
5269 uint attack_mode = ATTACK_MODE;
5270 uint markov_disable = MARKOV_DISABLE;
5271 uint markov_classic = MARKOV_CLASSIC;
5272 uint markov_threshold = MARKOV_THRESHOLD;
5273 char *markov_hcstat = NULL;
5274 char *outfile = NULL;
5275 uint outfile_format = OUTFILE_FORMAT;
5276 uint outfile_autohex = OUTFILE_AUTOHEX;
5277 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5278 uint restore = RESTORE;
5279 uint restore_timer = RESTORE_TIMER;
5280 uint restore_disable = RESTORE_DISABLE;
5281 uint status = STATUS;
5282 uint status_timer = STATUS_TIMER;
5283 uint status_automat = STATUS_AUTOMAT;
5284 uint loopback = LOOPBACK;
5285 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5286 char *session = NULL;
5287 uint hex_charset = HEX_CHARSET;
5288 uint hex_salt = HEX_SALT;
5289 uint hex_wordlist = HEX_WORDLIST;
5290 uint rp_gen = RP_GEN;
5291 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5292 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5293 uint rp_gen_seed = RP_GEN_SEED;
5294 char *rule_buf_l = (char *) RULE_BUF_L;
5295 char *rule_buf_r = (char *) RULE_BUF_R;
5296 uint increment = INCREMENT;
5297 uint increment_min = INCREMENT_MIN;
5298 uint increment_max = INCREMENT_MAX;
5299 char *cpu_affinity = NULL;
5300 OCL_PTR *ocl = NULL;
5301 char *opencl_devices = NULL;
5302 char *opencl_platforms = NULL;
5303 char *opencl_device_types = NULL;
5304 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5305 char *truecrypt_keyfiles = NULL;
5306 uint workload_profile = WORKLOAD_PROFILE;
5307 uint kernel_accel = KERNEL_ACCEL;
5308 uint kernel_loops = KERNEL_LOOPS;
5309 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5310 #ifdef HAVE_HWMON
5311 uint gpu_temp_abort = GPU_TEMP_ABORT;
5312 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5313 #ifdef HAVE_ADL
5314 uint powertune_enable = POWERTUNE_ENABLE;
5315 #endif
5316 #endif
5317 uint logfile_disable = LOGFILE_DISABLE;
5318 uint segment_size = SEGMENT_SIZE;
5319 uint scrypt_tmto = SCRYPT_TMTO;
5320 char separator = SEPARATOR;
5321 uint bitmap_min = BITMAP_MIN;
5322 uint bitmap_max = BITMAP_MAX;
5323 char *custom_charset_1 = NULL;
5324 char *custom_charset_2 = NULL;
5325 char *custom_charset_3 = NULL;
5326 char *custom_charset_4 = NULL;
5327
5328 #define IDX_HELP 'h'
5329 #define IDX_VERSION 'V'
5330 #define IDX_VERSION_LOWER 'v'
5331 #define IDX_QUIET 0xff02
5332 #define IDX_SHOW 0xff03
5333 #define IDX_LEFT 0xff04
5334 #define IDX_REMOVE 0xff05
5335 #define IDX_REMOVE_TIMER 0xff37
5336 #define IDX_SKIP 's'
5337 #define IDX_LIMIT 'l'
5338 #define IDX_KEYSPACE 0xff35
5339 #define IDX_POTFILE_DISABLE 0xff06
5340 #define IDX_POTFILE_PATH 0xffe0
5341 #define IDX_DEBUG_MODE 0xff43
5342 #define IDX_DEBUG_FILE 0xff44
5343 #define IDX_INDUCTION_DIR 0xff46
5344 #define IDX_OUTFILE_CHECK_DIR 0xff47
5345 #define IDX_USERNAME 0xff07
5346 #define IDX_FORCE 0xff08
5347 #define IDX_RUNTIME 0xff09
5348 #define IDX_BENCHMARK 'b'
5349 #define IDX_HASH_MODE 'm'
5350 #define IDX_ATTACK_MODE 'a'
5351 #define IDX_RP_FILE 'r'
5352 #define IDX_RP_GEN 'g'
5353 #define IDX_RP_GEN_FUNC_MIN 0xff10
5354 #define IDX_RP_GEN_FUNC_MAX 0xff11
5355 #define IDX_RP_GEN_SEED 0xff34
5356 #define IDX_RULE_BUF_L 'j'
5357 #define IDX_RULE_BUF_R 'k'
5358 #define IDX_INCREMENT 'i'
5359 #define IDX_INCREMENT_MIN 0xff12
5360 #define IDX_INCREMENT_MAX 0xff13
5361 #define IDX_OUTFILE 'o'
5362 #define IDX_OUTFILE_FORMAT 0xff14
5363 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5364 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5365 #define IDX_RESTORE 0xff15
5366 #define IDX_RESTORE_DISABLE 0xff27
5367 #define IDX_STATUS 0xff17
5368 #define IDX_STATUS_TIMER 0xff18
5369 #define IDX_STATUS_AUTOMAT 0xff50
5370 #define IDX_LOOPBACK 0xff38
5371 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5372 #define IDX_SESSION 0xff19
5373 #define IDX_HEX_CHARSET 0xff20
5374 #define IDX_HEX_SALT 0xff21
5375 #define IDX_HEX_WORDLIST 0xff40
5376 #define IDX_MARKOV_DISABLE 0xff22
5377 #define IDX_MARKOV_CLASSIC 0xff23
5378 #define IDX_MARKOV_THRESHOLD 't'
5379 #define IDX_MARKOV_HCSTAT 0xff24
5380 #define IDX_CPU_AFFINITY 0xff25
5381 #define IDX_OPENCL_DEVICES 'd'
5382 #define IDX_OPENCL_PLATFORMS 0xff72
5383 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5384 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5385 #define IDX_WORKLOAD_PROFILE 'w'
5386 #define IDX_KERNEL_ACCEL 'n'
5387 #define IDX_KERNEL_LOOPS 'u'
5388 #define IDX_GPU_TEMP_DISABLE 0xff29
5389 #define IDX_GPU_TEMP_ABORT 0xff30
5390 #define IDX_GPU_TEMP_RETAIN 0xff31
5391 #define IDX_POWERTUNE_ENABLE 0xff41
5392 #define IDX_LOGFILE_DISABLE 0xff51
5393 #define IDX_TRUECRYPT_KEYFILES 0xff52
5394 #define IDX_SCRYPT_TMTO 0xff61
5395 #define IDX_SEGMENT_SIZE 'c'
5396 #define IDX_SEPARATOR 'p'
5397 #define IDX_BITMAP_MIN 0xff70
5398 #define IDX_BITMAP_MAX 0xff71
5399 #define IDX_CUSTOM_CHARSET_1 '1'
5400 #define IDX_CUSTOM_CHARSET_2 '2'
5401 #define IDX_CUSTOM_CHARSET_3 '3'
5402 #define IDX_CUSTOM_CHARSET_4 '4'
5403
5404 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5405
5406 struct option long_options[] =
5407 {
5408 {"help", no_argument, 0, IDX_HELP},
5409 {"version", no_argument, 0, IDX_VERSION},
5410 {"quiet", no_argument, 0, IDX_QUIET},
5411 {"show", no_argument, 0, IDX_SHOW},
5412 {"left", no_argument, 0, IDX_LEFT},
5413 {"username", no_argument, 0, IDX_USERNAME},
5414 {"remove", no_argument, 0, IDX_REMOVE},
5415 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5416 {"skip", required_argument, 0, IDX_SKIP},
5417 {"limit", required_argument, 0, IDX_LIMIT},
5418 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5419 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5420 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5421 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5422 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5423 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5424 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5425 {"force", no_argument, 0, IDX_FORCE},
5426 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5427 {"restore", no_argument, 0, IDX_RESTORE},
5428 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5429 {"status", no_argument, 0, IDX_STATUS},
5430 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5431 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5432 {"loopback", no_argument, 0, IDX_LOOPBACK},
5433 {"weak-hash-threshold",
5434 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5435 {"session", required_argument, 0, IDX_SESSION},
5436 {"runtime", required_argument, 0, IDX_RUNTIME},
5437 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5438 {"generate-rules-func-min",
5439 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5440 {"generate-rules-func-max",
5441 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5442 {"generate-rules-seed",
5443 required_argument, 0, IDX_RP_GEN_SEED},
5444 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5445 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5446 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5447 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5448 {"rules-file", required_argument, 0, IDX_RP_FILE},
5449 {"outfile", required_argument, 0, IDX_OUTFILE},
5450 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5451 {"outfile-autohex-disable",
5452 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5453 {"outfile-check-timer",
5454 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5455 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5456 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5457 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5458 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5459 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5460 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5461 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5462 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5463 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5464 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5465 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5466 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5467 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5468 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5469 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5470 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5471 #ifdef HAVE_HWMON
5472 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5473 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5474 #ifdef HAVE_ADL
5475 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5476 #endif
5477 #endif // HAVE_HWMON
5478 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5479 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5480 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5481 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5482 // deprecated
5483 {"seperator", required_argument, 0, IDX_SEPARATOR},
5484 {"separator", required_argument, 0, IDX_SEPARATOR},
5485 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5486 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5487 {"increment", no_argument, 0, IDX_INCREMENT},
5488 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5489 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5490 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5491 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5492 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5493 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5494
5495 {0, 0, 0, 0}
5496 };
5497
5498 uint rp_files_cnt = 0;
5499
5500 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5501
5502 int option_index = 0;
5503 int c = -1;
5504
5505 optind = 1;
5506 optopt = 0;
5507
5508 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5509 {
5510 switch (c)
5511 {
5512 case IDX_HELP: usage = 1; break;
5513 case IDX_VERSION:
5514 case IDX_VERSION_LOWER: version = 1; break;
5515 case IDX_RESTORE: restore = 1; break;
5516 case IDX_SESSION: session = optarg; break;
5517 case IDX_SHOW: show = 1; break;
5518 case IDX_LEFT: left = 1; break;
5519 case '?': return (-1);
5520 }
5521 }
5522
5523 if (optopt != 0)
5524 {
5525 log_error ("ERROR: Invalid argument specified");
5526
5527 return (-1);
5528 }
5529
5530 /**
5531 * exit functions
5532 */
5533
5534 if (version)
5535 {
5536 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5537
5538 return (0);
5539 }
5540
5541 if (usage)
5542 {
5543 usage_big_print (PROGNAME);
5544
5545 return (0);
5546 }
5547
5548 /**
5549 * session needs to be set, always!
5550 */
5551
5552 if (session == NULL) session = (char *) PROGNAME;
5553
5554 /**
5555 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5556 */
5557
5558 char *exec_path = get_exec_path ();
5559
5560 #ifdef LINUX
5561
5562 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5563 char *resolved_exec_path = realpath (exec_path, NULL);
5564
5565 char *install_dir = get_install_dir (resolved_exec_path);
5566 char *profile_dir = NULL;
5567 char *session_dir = NULL;
5568 char *shared_dir = NULL;
5569
5570 if (strcmp (install_dir, resolved_install_folder) == 0)
5571 {
5572 struct passwd *pw = getpwuid (getuid ());
5573
5574 const char *homedir = pw->pw_dir;
5575
5576 profile_dir = get_profile_dir (homedir);
5577 session_dir = get_session_dir (profile_dir);
5578 shared_dir = strdup (SHARED_FOLDER);
5579
5580 mkdir (profile_dir, 0700);
5581 mkdir (session_dir, 0700);
5582 }
5583 else
5584 {
5585 profile_dir = install_dir;
5586 session_dir = install_dir;
5587 shared_dir = install_dir;
5588 }
5589
5590 myfree (resolved_install_folder);
5591 myfree (resolved_exec_path);
5592
5593 #else
5594
5595 char *install_dir = get_install_dir (exec_path);
5596 char *profile_dir = install_dir;
5597 char *session_dir = install_dir;
5598 char *shared_dir = install_dir;
5599
5600 #endif
5601
5602 data.install_dir = install_dir;
5603 data.profile_dir = profile_dir;
5604 data.session_dir = session_dir;
5605 data.shared_dir = shared_dir;
5606
5607 myfree (exec_path);
5608
5609 /**
5610 * kernel cache, we need to make sure folder exist
5611 */
5612
5613 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5614
5615 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5616
5617 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5618
5619 mkdir (kernels_folder, 0700);
5620
5621 myfree (kernels_folder);
5622
5623 /**
5624 * session
5625 */
5626
5627 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5628
5629 data.session = session;
5630
5631 char *eff_restore_file = (char *) mymalloc (session_size);
5632 char *new_restore_file = (char *) mymalloc (session_size);
5633
5634 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5635 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5636
5637 data.eff_restore_file = eff_restore_file;
5638 data.new_restore_file = new_restore_file;
5639
5640 if (((show == 1) || (left == 1)) && (restore == 1))
5641 {
5642 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5643 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5644
5645 return (-1);
5646 }
5647
5648 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5649 if ((show == 1) || (left == 1))
5650 {
5651 restore_disable = 1;
5652
5653 restore = 0;
5654 }
5655
5656 data.restore_disable = restore_disable;
5657
5658 restore_data_t *rd = init_restore (argc, argv);
5659
5660 data.rd = rd;
5661
5662 /**
5663 * restore file
5664 */
5665
5666 if (restore == 1)
5667 {
5668 read_restore (eff_restore_file, rd);
5669
5670 if (rd->version_bin < RESTORE_MIN)
5671 {
5672 log_error ("ERROR: Incompatible restore-file version");
5673
5674 return (-1);
5675 }
5676
5677 myargc = rd->argc;
5678 myargv = rd->argv;
5679
5680 #ifdef _POSIX
5681 rd->pid = getpid ();
5682 #elif _WIN
5683 rd->pid = GetCurrentProcessId ();
5684 #endif
5685 }
5686
5687 uint hash_mode_chgd = 0;
5688 uint runtime_chgd = 0;
5689 uint kernel_loops_chgd = 0;
5690 uint kernel_accel_chgd = 0;
5691 uint attack_mode_chgd = 0;
5692 uint outfile_format_chgd = 0;
5693 uint rp_gen_seed_chgd = 0;
5694 uint remove_timer_chgd = 0;
5695 uint increment_min_chgd = 0;
5696 uint increment_max_chgd = 0;
5697 uint workload_profile_chgd = 0;
5698 uint opencl_vector_width_chgd = 0;
5699
5700 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5701 uint gpu_temp_retain_chgd = 0;
5702 uint gpu_temp_abort_chgd = 0;
5703 #endif
5704
5705 optind = 1;
5706 optopt = 0;
5707 option_index = 0;
5708
5709 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5710 {
5711 switch (c)
5712 {
5713 //case IDX_HELP: usage = 1; break;
5714 //case IDX_VERSION: version = 1; break;
5715 //case IDX_RESTORE: restore = 1; break;
5716 case IDX_QUIET: quiet = 1; break;
5717 //case IDX_SHOW: show = 1; break;
5718 case IDX_SHOW: break;
5719 //case IDX_LEFT: left = 1; break;
5720 case IDX_LEFT: break;
5721 case IDX_USERNAME: username = 1; break;
5722 case IDX_REMOVE: remove = 1; break;
5723 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5724 remove_timer_chgd = 1; break;
5725 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5726 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5727 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5728 case IDX_DEBUG_FILE: debug_file = optarg; break;
5729 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5730 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5731 case IDX_FORCE: force = 1; break;
5732 case IDX_SKIP: skip = atoll (optarg); break;
5733 case IDX_LIMIT: limit = atoll (optarg); break;
5734 case IDX_KEYSPACE: keyspace = 1; break;
5735 case IDX_BENCHMARK: benchmark = 1; break;
5736 case IDX_RESTORE: break;
5737 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5738 case IDX_STATUS: status = 1; break;
5739 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5740 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5741 case IDX_LOOPBACK: loopback = 1; break;
5742 case IDX_WEAK_HASH_THRESHOLD:
5743 weak_hash_threshold = atoi (optarg); break;
5744 //case IDX_SESSION: session = optarg; break;
5745 case IDX_SESSION: break;
5746 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5747 hash_mode_chgd = 1; break;
5748 case IDX_RUNTIME: runtime = atoi (optarg);
5749 runtime_chgd = 1; break;
5750 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5751 attack_mode_chgd = 1; break;
5752 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5753 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5754 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5755 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5756 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5757 rp_gen_seed_chgd = 1; break;
5758 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5759 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5760 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5761 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5762 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5763 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5764 case IDX_OUTFILE: outfile = optarg; break;
5765 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5766 outfile_format_chgd = 1; break;
5767 case IDX_OUTFILE_AUTOHEX_DISABLE:
5768 outfile_autohex = 0; break;
5769 case IDX_OUTFILE_CHECK_TIMER:
5770 outfile_check_timer = atoi (optarg); break;
5771 case IDX_HEX_CHARSET: hex_charset = 1; break;
5772 case IDX_HEX_SALT: hex_salt = 1; break;
5773 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5774 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5775 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5776 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5777 case IDX_OPENCL_DEVICE_TYPES:
5778 opencl_device_types = optarg; break;
5779 case IDX_OPENCL_VECTOR_WIDTH:
5780 opencl_vector_width = atoi (optarg);
5781 opencl_vector_width_chgd = 1; break;
5782 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5783 workload_profile_chgd = 1; break;
5784 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5785 kernel_accel_chgd = 1; break;
5786 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5787 kernel_loops_chgd = 1; break;
5788 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5789 #ifdef HAVE_HWMON
5790 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5791 #ifdef HAVE_ADL
5792 gpu_temp_abort_chgd = 1;
5793 #endif
5794 break;
5795 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5796 #ifdef HAVE_ADL
5797 gpu_temp_retain_chgd = 1;
5798 #endif
5799 break;
5800 #ifdef HAVE_ADL
5801 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5802 #endif
5803 #endif // HAVE_HWMON
5804 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5805 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5806 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5807 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5808 case IDX_SEPARATOR: separator = optarg[0]; break;
5809 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5810 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5811 case IDX_INCREMENT: increment = 1; break;
5812 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5813 increment_min_chgd = 1; break;
5814 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5815 increment_max_chgd = 1; break;
5816 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5817 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5818 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5819 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5820
5821 default:
5822 log_error ("ERROR: Invalid argument specified");
5823 return (-1);
5824 }
5825 }
5826
5827 if (optopt != 0)
5828 {
5829 log_error ("ERROR: Invalid argument specified");
5830
5831 return (-1);
5832 }
5833
5834 /**
5835 * Inform user things getting started,
5836 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5837 * - we do not need to check algorithm_pos
5838 */
5839
5840 if (quiet == 0)
5841 {
5842 if (benchmark == 1)
5843 {
5844 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5845
5846 log_info ("");
5847 }
5848 else if (restore == 1)
5849 {
5850 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5851
5852 log_info ("");
5853 }
5854 else
5855 {
5856 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5857
5858 log_info ("");
5859 }
5860 }
5861
5862 /**
5863 * sanity check
5864 */
5865
5866 if (attack_mode > 7)
5867 {
5868 log_error ("ERROR: Invalid attack-mode specified");
5869
5870 return (-1);
5871 }
5872
5873 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5874 {
5875 log_error ("ERROR: Invalid runtime specified");
5876
5877 return (-1);
5878 }
5879
5880 if (hash_mode_chgd && hash_mode > 13500) // just added to remove compiler warnings for hash_mode_chgd
5881 {
5882 log_error ("ERROR: Invalid hash-type specified");
5883
5884 return (-1);
5885 }
5886
5887 // renamed hash modes
5888
5889 if (hash_mode_chgd)
5890 {
5891 int n = -1;
5892
5893 switch (hash_mode)
5894 {
5895 case 123: n = 124;
5896 break;
5897 }
5898
5899 if (n >= 0)
5900 {
5901 log_error ("Old -m specified, use -m %d instead", n);
5902
5903 return (-1);
5904 }
5905 }
5906
5907 if (username == 1)
5908 {
5909 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5910 {
5911 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5912
5913 return (-1);
5914 }
5915 }
5916
5917 if (outfile_format > 16)
5918 {
5919 log_error ("ERROR: Invalid outfile-format specified");
5920
5921 return (-1);
5922 }
5923
5924 if (left == 1)
5925 {
5926 if (outfile_format_chgd == 1)
5927 {
5928 if (outfile_format > 1)
5929 {
5930 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5931
5932 return (-1);
5933 }
5934 }
5935 else
5936 {
5937 outfile_format = OUTFILE_FMT_HASH;
5938 }
5939 }
5940
5941 if (show == 1)
5942 {
5943 if (outfile_format_chgd == 1)
5944 {
5945 if ((outfile_format > 7) && (outfile_format < 16))
5946 {
5947 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5948
5949 return (-1);
5950 }
5951 }
5952 }
5953
5954 if (increment_min < INCREMENT_MIN)
5955 {
5956 log_error ("ERROR: Invalid increment-min specified");
5957
5958 return (-1);
5959 }
5960
5961 if (increment_max > INCREMENT_MAX)
5962 {
5963 log_error ("ERROR: Invalid increment-max specified");
5964
5965 return (-1);
5966 }
5967
5968 if (increment_min > increment_max)
5969 {
5970 log_error ("ERROR: Invalid increment-min specified");
5971
5972 return (-1);
5973 }
5974
5975 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5976 {
5977 log_error ("ERROR: increment is not allowed in attack-mode 0");
5978
5979 return (-1);
5980 }
5981
5982 if ((increment == 0) && (increment_min_chgd == 1))
5983 {
5984 log_error ("ERROR: increment-min is only supported together with increment switch");
5985
5986 return (-1);
5987 }
5988
5989 if ((increment == 0) && (increment_max_chgd == 1))
5990 {
5991 log_error ("ERROR: increment-max is only supported together with increment switch");
5992
5993 return (-1);
5994 }
5995
5996 if (rp_files_cnt && rp_gen)
5997 {
5998 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5999
6000 return (-1);
6001 }
6002
6003 if (rp_files_cnt || rp_gen)
6004 {
6005 if (attack_mode != ATTACK_MODE_STRAIGHT)
6006 {
6007 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6008
6009 return (-1);
6010 }
6011 }
6012
6013 if (rp_gen_func_min > rp_gen_func_max)
6014 {
6015 log_error ("ERROR: Invalid rp-gen-func-min specified");
6016
6017 return (-1);
6018 }
6019
6020 if (kernel_accel_chgd == 1)
6021 {
6022 if (kernel_accel < 1)
6023 {
6024 log_error ("ERROR: Invalid kernel-accel specified");
6025
6026 return (-1);
6027 }
6028
6029 if (kernel_accel > 1024)
6030 {
6031 log_error ("ERROR: Invalid kernel-accel specified");
6032
6033 return (-1);
6034 }
6035 }
6036
6037 if (kernel_loops_chgd == 1)
6038 {
6039 if (kernel_loops < 1)
6040 {
6041 log_error ("ERROR: Invalid kernel-loops specified");
6042
6043 return (-1);
6044 }
6045
6046 if (kernel_loops > 1024)
6047 {
6048 log_error ("ERROR: Invalid kernel-loops specified");
6049
6050 return (-1);
6051 }
6052 }
6053
6054 if ((workload_profile < 1) || (workload_profile > 3))
6055 {
6056 log_error ("ERROR: workload-profile %i not available", workload_profile);
6057
6058 return (-1);
6059 }
6060
6061 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6062 {
6063 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6064
6065 return (-1);
6066 }
6067
6068 if (show == 1 || left == 1)
6069 {
6070 attack_mode = ATTACK_MODE_NONE;
6071
6072 if (remove == 1)
6073 {
6074 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6075
6076 return (-1);
6077 }
6078
6079 if (potfile_disable == 1)
6080 {
6081 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6082
6083 return (-1);
6084 }
6085 }
6086
6087 uint attack_kern = ATTACK_KERN_NONE;
6088
6089 switch (attack_mode)
6090 {
6091 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6092 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6093 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6094 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6095 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6096 }
6097
6098 if (benchmark == 0)
6099 {
6100 if (keyspace == 1)
6101 {
6102 int num_additional_params = 1;
6103
6104 if (attack_kern == ATTACK_KERN_COMBI)
6105 {
6106 num_additional_params = 2;
6107 }
6108
6109 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6110
6111 if (keyspace_wordlist_specified == 0) optind--;
6112 }
6113
6114 if (attack_kern == ATTACK_KERN_NONE)
6115 {
6116 if ((optind + 1) != myargc)
6117 {
6118 usage_mini_print (myargv[0]);
6119
6120 return (-1);
6121 }
6122 }
6123 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6124 {
6125 if ((optind + 1) > myargc)
6126 {
6127 usage_mini_print (myargv[0]);
6128
6129 return (-1);
6130 }
6131 }
6132 else if (attack_kern == ATTACK_KERN_COMBI)
6133 {
6134 if ((optind + 3) != myargc)
6135 {
6136 usage_mini_print (myargv[0]);
6137
6138 return (-1);
6139 }
6140 }
6141 else if (attack_kern == ATTACK_KERN_BF)
6142 {
6143 if ((optind + 1) > myargc)
6144 {
6145 usage_mini_print (myargv[0]);
6146
6147 return (-1);
6148 }
6149 }
6150 else
6151 {
6152 usage_mini_print (myargv[0]);
6153
6154 return (-1);
6155 }
6156 }
6157 else
6158 {
6159 if (myargv[optind] != 0)
6160 {
6161 log_error ("ERROR: Invalid argument for benchmark mode specified");
6162
6163 return (-1);
6164 }
6165
6166 if (attack_mode_chgd == 1)
6167 {
6168 if (attack_mode != ATTACK_MODE_BF)
6169 {
6170 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6171
6172 return (-1);
6173 }
6174 }
6175 }
6176
6177 if (skip != 0 && limit != 0)
6178 {
6179 limit += skip;
6180 }
6181
6182 if (keyspace == 1)
6183 {
6184 if (show == 1)
6185 {
6186 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6187
6188 return (-1);
6189 }
6190 else if (left == 1)
6191 {
6192 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6193
6194 return (-1);
6195 }
6196
6197 potfile_disable = 1;
6198
6199 restore_disable = 1;
6200
6201 restore = 0;
6202
6203 weak_hash_threshold = 0;
6204
6205 quiet = 1;
6206 }
6207
6208 if (remove_timer_chgd == 1)
6209 {
6210 if (remove == 0)
6211 {
6212 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6213
6214 return (-1);
6215 }
6216
6217 if (remove_timer < 1)
6218 {
6219 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6220
6221 return (-1);
6222 }
6223 }
6224
6225 if (loopback == 1)
6226 {
6227 if (attack_mode == ATTACK_MODE_STRAIGHT)
6228 {
6229 if ((rp_files_cnt == 0) && (rp_gen == 0))
6230 {
6231 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6232
6233 return (-1);
6234 }
6235 }
6236 else
6237 {
6238 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6239
6240 return (-1);
6241 }
6242 }
6243
6244 if (debug_mode > 0)
6245 {
6246 if (attack_mode != ATTACK_MODE_STRAIGHT)
6247 {
6248 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6249
6250 return (-1);
6251 }
6252
6253 if ((rp_files_cnt == 0) && (rp_gen == 0))
6254 {
6255 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6256
6257 return (-1);
6258 }
6259 }
6260
6261 if (debug_mode > 4)
6262 {
6263 log_error ("ERROR: Invalid debug-mode specified");
6264
6265 return (-1);
6266 }
6267
6268 if (debug_file != NULL)
6269 {
6270 if (debug_mode < 1)
6271 {
6272 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6273
6274 return (-1);
6275 }
6276 }
6277
6278 if (induction_dir != NULL)
6279 {
6280 if (attack_mode == ATTACK_MODE_BF)
6281 {
6282 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6283
6284 return (-1);
6285 }
6286 }
6287
6288 if (attack_mode != ATTACK_MODE_STRAIGHT)
6289 {
6290 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6291 {
6292 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6293
6294 return (-1);
6295 }
6296
6297 weak_hash_threshold = 0;
6298 }
6299
6300 /**
6301 * induction directory
6302 */
6303
6304 char *induction_directory = NULL;
6305
6306 if (attack_mode != ATTACK_MODE_BF)
6307 {
6308 if (induction_dir == NULL)
6309 {
6310 induction_directory = (char *) mymalloc (session_size);
6311
6312 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6313
6314 // create induction folder if it does not already exist
6315
6316 if (keyspace == 0)
6317 {
6318 if (rmdir (induction_directory) == -1)
6319 {
6320 if (errno == ENOENT)
6321 {
6322 // good, we can ignore
6323 }
6324 else if (errno == ENOTEMPTY)
6325 {
6326 char *induction_directory_mv = (char *) mymalloc (session_size);
6327
6328 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6329
6330 if (rename (induction_directory, induction_directory_mv) != 0)
6331 {
6332 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6333
6334 return (-1);
6335 }
6336 }
6337 else
6338 {
6339 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6340
6341 return (-1);
6342 }
6343 }
6344
6345 if (mkdir (induction_directory, 0700) == -1)
6346 {
6347 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6348
6349 return (-1);
6350 }
6351 }
6352 }
6353 else
6354 {
6355 induction_directory = induction_dir;
6356 }
6357 }
6358
6359 data.induction_directory = induction_directory;
6360
6361 /**
6362 * loopback
6363 */
6364
6365 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6366
6367 char *loopback_file = (char *) mymalloc (loopback_size);
6368
6369 /**
6370 * tuning db
6371 */
6372
6373 char tuning_db_file[256] = { 0 };
6374
6375 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6376
6377 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6378
6379 /**
6380 * outfile-check directory
6381 */
6382
6383 char *outfile_check_directory = NULL;
6384
6385 if (outfile_check_dir == NULL)
6386 {
6387 outfile_check_directory = (char *) mymalloc (session_size);
6388
6389 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6390 }
6391 else
6392 {
6393 outfile_check_directory = outfile_check_dir;
6394 }
6395
6396 data.outfile_check_directory = outfile_check_directory;
6397
6398 if (keyspace == 0)
6399 {
6400 struct stat outfile_check_stat;
6401
6402 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6403 {
6404 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6405
6406 if (is_dir == 0)
6407 {
6408 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6409
6410 return (-1);
6411 }
6412 }
6413 else if (outfile_check_dir == NULL)
6414 {
6415 if (mkdir (outfile_check_directory, 0700) == -1)
6416 {
6417 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6418
6419 return (-1);
6420 }
6421 }
6422 }
6423
6424 /**
6425 * special other stuff
6426 */
6427
6428 if (hash_mode == 9710)
6429 {
6430 outfile_format = 5;
6431 outfile_format_chgd = 1;
6432 }
6433
6434 if (hash_mode == 9810)
6435 {
6436 outfile_format = 5;
6437 outfile_format_chgd = 1;
6438 }
6439
6440 if (hash_mode == 10410)
6441 {
6442 outfile_format = 5;
6443 outfile_format_chgd = 1;
6444 }
6445
6446 /**
6447 * store stuff
6448 */
6449
6450 data.hash_mode = hash_mode;
6451 data.restore = restore;
6452 data.restore_timer = restore_timer;
6453 data.restore_disable = restore_disable;
6454 data.status = status;
6455 data.status_timer = status_timer;
6456 data.status_automat = status_automat;
6457 data.loopback = loopback;
6458 data.runtime = runtime;
6459 data.remove = remove;
6460 data.remove_timer = remove_timer;
6461 data.debug_mode = debug_mode;
6462 data.debug_file = debug_file;
6463 data.username = username;
6464 data.quiet = quiet;
6465 data.outfile = outfile;
6466 data.outfile_format = outfile_format;
6467 data.outfile_autohex = outfile_autohex;
6468 data.hex_charset = hex_charset;
6469 data.hex_salt = hex_salt;
6470 data.hex_wordlist = hex_wordlist;
6471 data.separator = separator;
6472 data.rp_files = rp_files;
6473 data.rp_files_cnt = rp_files_cnt;
6474 data.rp_gen = rp_gen;
6475 data.rp_gen_seed = rp_gen_seed;
6476 data.force = force;
6477 data.benchmark = benchmark;
6478 data.skip = skip;
6479 data.limit = limit;
6480 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6481 data.powertune_enable = powertune_enable;
6482 #endif
6483 data.logfile_disable = logfile_disable;
6484 data.truecrypt_keyfiles = truecrypt_keyfiles;
6485 data.scrypt_tmto = scrypt_tmto;
6486 data.workload_profile = workload_profile;
6487
6488 /**
6489 * cpu affinity
6490 */
6491
6492 if (cpu_affinity)
6493 {
6494 set_cpu_affinity (cpu_affinity);
6495 }
6496
6497 if (rp_gen_seed_chgd == 0)
6498 {
6499 srand (proc_start);
6500 }
6501 else
6502 {
6503 srand (rp_gen_seed);
6504 }
6505
6506 /**
6507 * logfile init
6508 */
6509
6510 if (logfile_disable == 0)
6511 {
6512 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6513
6514 char *logfile = (char *) mymalloc (logfile_size);
6515
6516 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6517
6518 data.logfile = logfile;
6519
6520 char *topid = logfile_generate_topid ();
6521
6522 data.topid = topid;
6523 }
6524
6525 // logfile_append() checks for logfile_disable internally to make it easier from here
6526
6527 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6528 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6529 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6530 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6531 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6532 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6533 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6534 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6535 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6536 #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));
6537
6538 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6539 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6540 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6541 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6542 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6543 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6544 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6545 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6546
6547 logfile_top_msg ("START");
6548
6549 logfile_top_uint (attack_mode);
6550 logfile_top_uint (attack_kern);
6551 logfile_top_uint (benchmark);
6552 logfile_top_uint (bitmap_min);
6553 logfile_top_uint (bitmap_max);
6554 logfile_top_uint (debug_mode);
6555 logfile_top_uint (force);
6556 logfile_top_uint (kernel_accel);
6557 logfile_top_uint (kernel_loops);
6558 logfile_top_uint (gpu_temp_disable);
6559 #ifdef HAVE_HWMON
6560 logfile_top_uint (gpu_temp_abort);
6561 logfile_top_uint (gpu_temp_retain);
6562 #endif
6563 logfile_top_uint (hash_mode);
6564 logfile_top_uint (hex_charset);
6565 logfile_top_uint (hex_salt);
6566 logfile_top_uint (hex_wordlist);
6567 logfile_top_uint (increment);
6568 logfile_top_uint (increment_max);
6569 logfile_top_uint (increment_min);
6570 logfile_top_uint (keyspace);
6571 logfile_top_uint (left);
6572 logfile_top_uint (logfile_disable);
6573 logfile_top_uint (loopback);
6574 logfile_top_uint (markov_classic);
6575 logfile_top_uint (markov_disable);
6576 logfile_top_uint (markov_threshold);
6577 logfile_top_uint (outfile_autohex);
6578 logfile_top_uint (outfile_check_timer);
6579 logfile_top_uint (outfile_format);
6580 logfile_top_uint (potfile_disable);
6581 logfile_top_string (potfile_path);
6582 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6583 logfile_top_uint (powertune_enable);
6584 #endif
6585 logfile_top_uint (scrypt_tmto);
6586 logfile_top_uint (quiet);
6587 logfile_top_uint (remove);
6588 logfile_top_uint (remove_timer);
6589 logfile_top_uint (restore);
6590 logfile_top_uint (restore_disable);
6591 logfile_top_uint (restore_timer);
6592 logfile_top_uint (rp_gen);
6593 logfile_top_uint (rp_gen_func_max);
6594 logfile_top_uint (rp_gen_func_min);
6595 logfile_top_uint (rp_gen_seed);
6596 logfile_top_uint (runtime);
6597 logfile_top_uint (segment_size);
6598 logfile_top_uint (show);
6599 logfile_top_uint (status);
6600 logfile_top_uint (status_automat);
6601 logfile_top_uint (status_timer);
6602 logfile_top_uint (usage);
6603 logfile_top_uint (username);
6604 logfile_top_uint (version);
6605 logfile_top_uint (weak_hash_threshold);
6606 logfile_top_uint (workload_profile);
6607 logfile_top_uint64 (limit);
6608 logfile_top_uint64 (skip);
6609 logfile_top_char (separator);
6610 logfile_top_string (cpu_affinity);
6611 logfile_top_string (custom_charset_1);
6612 logfile_top_string (custom_charset_2);
6613 logfile_top_string (custom_charset_3);
6614 logfile_top_string (custom_charset_4);
6615 logfile_top_string (debug_file);
6616 logfile_top_string (opencl_devices);
6617 logfile_top_string (opencl_platforms);
6618 logfile_top_string (opencl_device_types);
6619 logfile_top_uint (opencl_vector_width);
6620 logfile_top_string (induction_dir);
6621 logfile_top_string (markov_hcstat);
6622 logfile_top_string (outfile);
6623 logfile_top_string (outfile_check_dir);
6624 logfile_top_string (rule_buf_l);
6625 logfile_top_string (rule_buf_r);
6626 logfile_top_string (session);
6627 logfile_top_string (truecrypt_keyfiles);
6628
6629 /**
6630 * Init OpenCL library loader
6631 */
6632
6633 if (keyspace == 0)
6634 {
6635 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6636
6637 ocl_init (ocl);
6638
6639 data.ocl = ocl;
6640 }
6641
6642 /**
6643 * OpenCL platform selection
6644 */
6645
6646 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6647
6648 /**
6649 * OpenCL device selection
6650 */
6651
6652 u32 devices_filter = setup_devices_filter (opencl_devices);
6653
6654 /**
6655 * OpenCL device type selection
6656 */
6657
6658 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6659
6660 /**
6661 * benchmark
6662 */
6663
6664 if (benchmark == 1)
6665 {
6666 /**
6667 * disable useless stuff for benchmark
6668 */
6669
6670 status_timer = 0;
6671 restore_timer = 0;
6672 restore_disable = 1;
6673 potfile_disable = 1;
6674 weak_hash_threshold = 0;
6675 gpu_temp_disable = 1;
6676
6677 data.status_timer = status_timer;
6678 data.restore_timer = restore_timer;
6679 data.restore_disable = restore_disable;
6680
6681 /**
6682 * force attack mode to be bruteforce
6683 */
6684
6685 attack_mode = ATTACK_MODE_BF;
6686 attack_kern = ATTACK_KERN_BF;
6687
6688 if (workload_profile_chgd == 0)
6689 {
6690 workload_profile = 3;
6691
6692 data.workload_profile = workload_profile;
6693 }
6694 }
6695
6696 /**
6697 * config
6698 */
6699
6700 uint hash_type = 0;
6701 uint salt_type = 0;
6702 uint attack_exec = 0;
6703 uint opts_type = 0;
6704 uint kern_type = 0;
6705 uint dgst_size = 0;
6706 uint esalt_size = 0;
6707 uint opti_type = 0;
6708 uint dgst_pos0 = -1;
6709 uint dgst_pos1 = -1;
6710 uint dgst_pos2 = -1;
6711 uint dgst_pos3 = -1;
6712
6713 int (*parse_func) (char *, uint, hash_t *);
6714 int (*sort_by_digest) (const void *, const void *);
6715
6716 uint algorithm_pos = 0;
6717 uint algorithm_max = 1;
6718
6719 uint *algorithms = default_benchmark_algorithms;
6720
6721 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6722
6723 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6724 {
6725 /*
6726 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6727 * the following algos are skipped entirely
6728 */
6729
6730 if (algorithm_pos > 0)
6731 {
6732 local_free (rd);
6733
6734 rd = init_restore (argc, argv);
6735
6736 data.rd = rd;
6737 }
6738
6739 /**
6740 * update hash_mode in case of multihash benchmark
6741 */
6742
6743 if (benchmark == 1)
6744 {
6745 if (hash_mode_chgd == 0)
6746 {
6747 hash_mode = algorithms[algorithm_pos];
6748
6749 data.hash_mode = hash_mode;
6750 }
6751
6752 quiet = 1;
6753
6754 data.quiet = quiet;
6755 }
6756
6757 switch (hash_mode)
6758 {
6759 case 0: hash_type = HASH_TYPE_MD5;
6760 salt_type = SALT_TYPE_NONE;
6761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6762 opts_type = OPTS_TYPE_PT_GENERATE_LE
6763 | OPTS_TYPE_PT_ADD80
6764 | OPTS_TYPE_PT_ADDBITS14;
6765 kern_type = KERN_TYPE_MD5;
6766 dgst_size = DGST_SIZE_4_4;
6767 parse_func = md5_parse_hash;
6768 sort_by_digest = sort_by_digest_4_4;
6769 opti_type = OPTI_TYPE_ZERO_BYTE
6770 | OPTI_TYPE_PRECOMPUTE_INIT
6771 | OPTI_TYPE_PRECOMPUTE_MERKLE
6772 | OPTI_TYPE_MEET_IN_MIDDLE
6773 | OPTI_TYPE_EARLY_SKIP
6774 | OPTI_TYPE_NOT_ITERATED
6775 | OPTI_TYPE_NOT_SALTED
6776 | OPTI_TYPE_RAW_HASH;
6777 dgst_pos0 = 0;
6778 dgst_pos1 = 3;
6779 dgst_pos2 = 2;
6780 dgst_pos3 = 1;
6781 break;
6782
6783 case 10: hash_type = HASH_TYPE_MD5;
6784 salt_type = SALT_TYPE_INTERN;
6785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6786 opts_type = OPTS_TYPE_PT_GENERATE_LE
6787 | OPTS_TYPE_ST_ADD80
6788 | OPTS_TYPE_ST_ADDBITS14;
6789 kern_type = KERN_TYPE_MD5_PWSLT;
6790 dgst_size = DGST_SIZE_4_4;
6791 parse_func = md5s_parse_hash;
6792 sort_by_digest = sort_by_digest_4_4;
6793 opti_type = OPTI_TYPE_ZERO_BYTE
6794 | OPTI_TYPE_PRECOMPUTE_INIT
6795 | OPTI_TYPE_PRECOMPUTE_MERKLE
6796 | OPTI_TYPE_MEET_IN_MIDDLE
6797 | OPTI_TYPE_EARLY_SKIP
6798 | OPTI_TYPE_NOT_ITERATED
6799 | OPTI_TYPE_APPENDED_SALT
6800 | OPTI_TYPE_RAW_HASH;
6801 dgst_pos0 = 0;
6802 dgst_pos1 = 3;
6803 dgst_pos2 = 2;
6804 dgst_pos3 = 1;
6805 break;
6806
6807 case 11: hash_type = HASH_TYPE_MD5;
6808 salt_type = SALT_TYPE_INTERN;
6809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6810 opts_type = OPTS_TYPE_PT_GENERATE_LE
6811 | OPTS_TYPE_ST_ADD80
6812 | OPTS_TYPE_ST_ADDBITS14;
6813 kern_type = KERN_TYPE_MD5_PWSLT;
6814 dgst_size = DGST_SIZE_4_4;
6815 parse_func = joomla_parse_hash;
6816 sort_by_digest = sort_by_digest_4_4;
6817 opti_type = OPTI_TYPE_ZERO_BYTE
6818 | OPTI_TYPE_PRECOMPUTE_INIT
6819 | OPTI_TYPE_PRECOMPUTE_MERKLE
6820 | OPTI_TYPE_MEET_IN_MIDDLE
6821 | OPTI_TYPE_EARLY_SKIP
6822 | OPTI_TYPE_NOT_ITERATED
6823 | OPTI_TYPE_APPENDED_SALT
6824 | OPTI_TYPE_RAW_HASH;
6825 dgst_pos0 = 0;
6826 dgst_pos1 = 3;
6827 dgst_pos2 = 2;
6828 dgst_pos3 = 1;
6829 break;
6830
6831 case 12: hash_type = HASH_TYPE_MD5;
6832 salt_type = SALT_TYPE_INTERN;
6833 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6834 opts_type = OPTS_TYPE_PT_GENERATE_LE
6835 | OPTS_TYPE_ST_ADD80
6836 | OPTS_TYPE_ST_ADDBITS14;
6837 kern_type = KERN_TYPE_MD5_PWSLT;
6838 dgst_size = DGST_SIZE_4_4;
6839 parse_func = postgresql_parse_hash;
6840 sort_by_digest = sort_by_digest_4_4;
6841 opti_type = OPTI_TYPE_ZERO_BYTE
6842 | OPTI_TYPE_PRECOMPUTE_INIT
6843 | OPTI_TYPE_PRECOMPUTE_MERKLE
6844 | OPTI_TYPE_MEET_IN_MIDDLE
6845 | OPTI_TYPE_EARLY_SKIP
6846 | OPTI_TYPE_NOT_ITERATED
6847 | OPTI_TYPE_APPENDED_SALT
6848 | OPTI_TYPE_RAW_HASH;
6849 dgst_pos0 = 0;
6850 dgst_pos1 = 3;
6851 dgst_pos2 = 2;
6852 dgst_pos3 = 1;
6853 break;
6854
6855 case 20: hash_type = HASH_TYPE_MD5;
6856 salt_type = SALT_TYPE_INTERN;
6857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6858 opts_type = OPTS_TYPE_PT_GENERATE_LE
6859 | OPTS_TYPE_PT_ADD80
6860 | OPTS_TYPE_PT_ADDBITS14;
6861 kern_type = KERN_TYPE_MD5_SLTPW;
6862 dgst_size = DGST_SIZE_4_4;
6863 parse_func = md5s_parse_hash;
6864 sort_by_digest = sort_by_digest_4_4;
6865 opti_type = OPTI_TYPE_ZERO_BYTE
6866 | OPTI_TYPE_PRECOMPUTE_INIT
6867 | OPTI_TYPE_PRECOMPUTE_MERKLE
6868 | OPTI_TYPE_EARLY_SKIP
6869 | OPTI_TYPE_NOT_ITERATED
6870 | OPTI_TYPE_PREPENDED_SALT
6871 | OPTI_TYPE_RAW_HASH;
6872 dgst_pos0 = 0;
6873 dgst_pos1 = 3;
6874 dgst_pos2 = 2;
6875 dgst_pos3 = 1;
6876 break;
6877
6878 case 21: hash_type = HASH_TYPE_MD5;
6879 salt_type = SALT_TYPE_INTERN;
6880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6881 opts_type = OPTS_TYPE_PT_GENERATE_LE
6882 | OPTS_TYPE_PT_ADD80
6883 | OPTS_TYPE_PT_ADDBITS14;
6884 kern_type = KERN_TYPE_MD5_SLTPW;
6885 dgst_size = DGST_SIZE_4_4;
6886 parse_func = osc_parse_hash;
6887 sort_by_digest = sort_by_digest_4_4;
6888 opti_type = OPTI_TYPE_ZERO_BYTE
6889 | OPTI_TYPE_PRECOMPUTE_INIT
6890 | OPTI_TYPE_PRECOMPUTE_MERKLE
6891 | OPTI_TYPE_EARLY_SKIP
6892 | OPTI_TYPE_NOT_ITERATED
6893 | OPTI_TYPE_PREPENDED_SALT
6894 | OPTI_TYPE_RAW_HASH;
6895 dgst_pos0 = 0;
6896 dgst_pos1 = 3;
6897 dgst_pos2 = 2;
6898 dgst_pos3 = 1;
6899 break;
6900
6901 case 22: hash_type = HASH_TYPE_MD5;
6902 salt_type = SALT_TYPE_EMBEDDED;
6903 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6904 opts_type = OPTS_TYPE_PT_GENERATE_LE
6905 | OPTS_TYPE_PT_ADD80
6906 | OPTS_TYPE_PT_ADDBITS14;
6907 kern_type = KERN_TYPE_MD5_SLTPW;
6908 dgst_size = DGST_SIZE_4_4;
6909 parse_func = netscreen_parse_hash;
6910 sort_by_digest = sort_by_digest_4_4;
6911 opti_type = OPTI_TYPE_ZERO_BYTE
6912 | OPTI_TYPE_PRECOMPUTE_INIT
6913 | OPTI_TYPE_PRECOMPUTE_MERKLE
6914 | OPTI_TYPE_EARLY_SKIP
6915 | OPTI_TYPE_NOT_ITERATED
6916 | OPTI_TYPE_PREPENDED_SALT
6917 | OPTI_TYPE_RAW_HASH;
6918 dgst_pos0 = 0;
6919 dgst_pos1 = 3;
6920 dgst_pos2 = 2;
6921 dgst_pos3 = 1;
6922 break;
6923
6924 case 23: hash_type = HASH_TYPE_MD5;
6925 salt_type = SALT_TYPE_EMBEDDED;
6926 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6927 opts_type = OPTS_TYPE_PT_GENERATE_LE
6928 | OPTS_TYPE_PT_ADD80
6929 | OPTS_TYPE_PT_ADDBITS14;
6930 kern_type = KERN_TYPE_MD5_SLTPW;
6931 dgst_size = DGST_SIZE_4_4;
6932 parse_func = skype_parse_hash;
6933 sort_by_digest = sort_by_digest_4_4;
6934 opti_type = OPTI_TYPE_ZERO_BYTE
6935 | OPTI_TYPE_PRECOMPUTE_INIT
6936 | OPTI_TYPE_PRECOMPUTE_MERKLE
6937 | OPTI_TYPE_EARLY_SKIP
6938 | OPTI_TYPE_NOT_ITERATED
6939 | OPTI_TYPE_PREPENDED_SALT
6940 | OPTI_TYPE_RAW_HASH;
6941 dgst_pos0 = 0;
6942 dgst_pos1 = 3;
6943 dgst_pos2 = 2;
6944 dgst_pos3 = 1;
6945 break;
6946
6947 case 30: hash_type = HASH_TYPE_MD5;
6948 salt_type = SALT_TYPE_INTERN;
6949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6950 opts_type = OPTS_TYPE_PT_GENERATE_LE
6951 | OPTS_TYPE_PT_UNICODE
6952 | OPTS_TYPE_ST_ADD80
6953 | OPTS_TYPE_ST_ADDBITS14;
6954 kern_type = KERN_TYPE_MD5_PWUSLT;
6955 dgst_size = DGST_SIZE_4_4;
6956 parse_func = md5s_parse_hash;
6957 sort_by_digest = sort_by_digest_4_4;
6958 opti_type = OPTI_TYPE_ZERO_BYTE
6959 | OPTI_TYPE_PRECOMPUTE_INIT
6960 | OPTI_TYPE_PRECOMPUTE_MERKLE
6961 | OPTI_TYPE_MEET_IN_MIDDLE
6962 | OPTI_TYPE_EARLY_SKIP
6963 | OPTI_TYPE_NOT_ITERATED
6964 | OPTI_TYPE_APPENDED_SALT
6965 | OPTI_TYPE_RAW_HASH;
6966 dgst_pos0 = 0;
6967 dgst_pos1 = 3;
6968 dgst_pos2 = 2;
6969 dgst_pos3 = 1;
6970 break;
6971
6972 case 40: hash_type = HASH_TYPE_MD5;
6973 salt_type = SALT_TYPE_INTERN;
6974 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6975 opts_type = OPTS_TYPE_PT_GENERATE_LE
6976 | OPTS_TYPE_PT_ADD80
6977 | OPTS_TYPE_PT_ADDBITS14
6978 | OPTS_TYPE_PT_UNICODE;
6979 kern_type = KERN_TYPE_MD5_SLTPWU;
6980 dgst_size = DGST_SIZE_4_4;
6981 parse_func = md5s_parse_hash;
6982 sort_by_digest = sort_by_digest_4_4;
6983 opti_type = OPTI_TYPE_ZERO_BYTE
6984 | OPTI_TYPE_PRECOMPUTE_INIT
6985 | OPTI_TYPE_PRECOMPUTE_MERKLE
6986 | OPTI_TYPE_EARLY_SKIP
6987 | OPTI_TYPE_NOT_ITERATED
6988 | OPTI_TYPE_PREPENDED_SALT
6989 | OPTI_TYPE_RAW_HASH;
6990 dgst_pos0 = 0;
6991 dgst_pos1 = 3;
6992 dgst_pos2 = 2;
6993 dgst_pos3 = 1;
6994 break;
6995
6996 case 50: hash_type = HASH_TYPE_MD5;
6997 salt_type = SALT_TYPE_INTERN;
6998 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6999 opts_type = OPTS_TYPE_PT_GENERATE_LE
7000 | OPTS_TYPE_ST_ADD80
7001 | OPTS_TYPE_ST_ADDBITS14;
7002 kern_type = KERN_TYPE_HMACMD5_PW;
7003 dgst_size = DGST_SIZE_4_4;
7004 parse_func = hmacmd5_parse_hash;
7005 sort_by_digest = sort_by_digest_4_4;
7006 opti_type = OPTI_TYPE_ZERO_BYTE
7007 | OPTI_TYPE_NOT_ITERATED;
7008 dgst_pos0 = 0;
7009 dgst_pos1 = 3;
7010 dgst_pos2 = 2;
7011 dgst_pos3 = 1;
7012 break;
7013
7014 case 60: hash_type = HASH_TYPE_MD5;
7015 salt_type = SALT_TYPE_INTERN;
7016 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7017 opts_type = OPTS_TYPE_PT_GENERATE_LE
7018 | OPTS_TYPE_PT_ADD80
7019 | OPTS_TYPE_PT_ADDBITS14;
7020 kern_type = KERN_TYPE_HMACMD5_SLT;
7021 dgst_size = DGST_SIZE_4_4;
7022 parse_func = hmacmd5_parse_hash;
7023 sort_by_digest = sort_by_digest_4_4;
7024 opti_type = OPTI_TYPE_ZERO_BYTE
7025 | OPTI_TYPE_NOT_ITERATED;
7026 dgst_pos0 = 0;
7027 dgst_pos1 = 3;
7028 dgst_pos2 = 2;
7029 dgst_pos3 = 1;
7030 break;
7031
7032 case 100: hash_type = HASH_TYPE_SHA1;
7033 salt_type = SALT_TYPE_NONE;
7034 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7035 opts_type = OPTS_TYPE_PT_GENERATE_BE
7036 | OPTS_TYPE_PT_ADD80
7037 | OPTS_TYPE_PT_ADDBITS15;
7038 kern_type = KERN_TYPE_SHA1;
7039 dgst_size = DGST_SIZE_4_5;
7040 parse_func = sha1_parse_hash;
7041 sort_by_digest = sort_by_digest_4_5;
7042 opti_type = OPTI_TYPE_ZERO_BYTE
7043 | OPTI_TYPE_PRECOMPUTE_INIT
7044 | OPTI_TYPE_PRECOMPUTE_MERKLE
7045 | OPTI_TYPE_EARLY_SKIP
7046 | OPTI_TYPE_NOT_ITERATED
7047 | OPTI_TYPE_NOT_SALTED
7048 | OPTI_TYPE_RAW_HASH;
7049 dgst_pos0 = 3;
7050 dgst_pos1 = 4;
7051 dgst_pos2 = 2;
7052 dgst_pos3 = 1;
7053 break;
7054
7055 case 101: hash_type = HASH_TYPE_SHA1;
7056 salt_type = SALT_TYPE_NONE;
7057 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7058 opts_type = OPTS_TYPE_PT_GENERATE_BE
7059 | OPTS_TYPE_PT_ADD80
7060 | OPTS_TYPE_PT_ADDBITS15;
7061 kern_type = KERN_TYPE_SHA1;
7062 dgst_size = DGST_SIZE_4_5;
7063 parse_func = sha1b64_parse_hash;
7064 sort_by_digest = sort_by_digest_4_5;
7065 opti_type = OPTI_TYPE_ZERO_BYTE
7066 | OPTI_TYPE_PRECOMPUTE_INIT
7067 | OPTI_TYPE_PRECOMPUTE_MERKLE
7068 | OPTI_TYPE_EARLY_SKIP
7069 | OPTI_TYPE_NOT_ITERATED
7070 | OPTI_TYPE_NOT_SALTED
7071 | OPTI_TYPE_RAW_HASH;
7072 dgst_pos0 = 3;
7073 dgst_pos1 = 4;
7074 dgst_pos2 = 2;
7075 dgst_pos3 = 1;
7076 break;
7077
7078 case 110: hash_type = HASH_TYPE_SHA1;
7079 salt_type = SALT_TYPE_INTERN;
7080 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7081 opts_type = OPTS_TYPE_PT_GENERATE_BE
7082 | OPTS_TYPE_ST_ADD80
7083 | OPTS_TYPE_ST_ADDBITS15;
7084 kern_type = KERN_TYPE_SHA1_PWSLT;
7085 dgst_size = DGST_SIZE_4_5;
7086 parse_func = sha1s_parse_hash;
7087 sort_by_digest = sort_by_digest_4_5;
7088 opti_type = OPTI_TYPE_ZERO_BYTE
7089 | OPTI_TYPE_PRECOMPUTE_INIT
7090 | OPTI_TYPE_PRECOMPUTE_MERKLE
7091 | OPTI_TYPE_EARLY_SKIP
7092 | OPTI_TYPE_NOT_ITERATED
7093 | OPTI_TYPE_APPENDED_SALT
7094 | OPTI_TYPE_RAW_HASH;
7095 dgst_pos0 = 3;
7096 dgst_pos1 = 4;
7097 dgst_pos2 = 2;
7098 dgst_pos3 = 1;
7099 break;
7100
7101 case 111: hash_type = HASH_TYPE_SHA1;
7102 salt_type = SALT_TYPE_EMBEDDED;
7103 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7104 opts_type = OPTS_TYPE_PT_GENERATE_BE
7105 | OPTS_TYPE_ST_ADD80
7106 | OPTS_TYPE_ST_ADDBITS15;
7107 kern_type = KERN_TYPE_SHA1_PWSLT;
7108 dgst_size = DGST_SIZE_4_5;
7109 parse_func = sha1b64s_parse_hash;
7110 sort_by_digest = sort_by_digest_4_5;
7111 opti_type = OPTI_TYPE_ZERO_BYTE
7112 | OPTI_TYPE_PRECOMPUTE_INIT
7113 | OPTI_TYPE_PRECOMPUTE_MERKLE
7114 | OPTI_TYPE_EARLY_SKIP
7115 | OPTI_TYPE_NOT_ITERATED
7116 | OPTI_TYPE_APPENDED_SALT
7117 | OPTI_TYPE_RAW_HASH;
7118 dgst_pos0 = 3;
7119 dgst_pos1 = 4;
7120 dgst_pos2 = 2;
7121 dgst_pos3 = 1;
7122 break;
7123
7124 case 112: hash_type = HASH_TYPE_SHA1;
7125 salt_type = SALT_TYPE_INTERN;
7126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7127 opts_type = OPTS_TYPE_PT_GENERATE_BE
7128 | OPTS_TYPE_ST_ADD80
7129 | OPTS_TYPE_ST_ADDBITS15
7130 | OPTS_TYPE_ST_HEX;
7131 kern_type = KERN_TYPE_SHA1_PWSLT;
7132 dgst_size = DGST_SIZE_4_5;
7133 parse_func = oracles_parse_hash;
7134 sort_by_digest = sort_by_digest_4_5;
7135 opti_type = OPTI_TYPE_ZERO_BYTE
7136 | OPTI_TYPE_PRECOMPUTE_INIT
7137 | OPTI_TYPE_PRECOMPUTE_MERKLE
7138 | OPTI_TYPE_EARLY_SKIP
7139 | OPTI_TYPE_NOT_ITERATED
7140 | OPTI_TYPE_APPENDED_SALT
7141 | OPTI_TYPE_RAW_HASH;
7142 dgst_pos0 = 3;
7143 dgst_pos1 = 4;
7144 dgst_pos2 = 2;
7145 dgst_pos3 = 1;
7146 break;
7147
7148 case 120: hash_type = HASH_TYPE_SHA1;
7149 salt_type = SALT_TYPE_INTERN;
7150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7151 opts_type = OPTS_TYPE_PT_GENERATE_BE
7152 | OPTS_TYPE_PT_ADD80
7153 | OPTS_TYPE_PT_ADDBITS15;
7154 kern_type = KERN_TYPE_SHA1_SLTPW;
7155 dgst_size = DGST_SIZE_4_5;
7156 parse_func = sha1s_parse_hash;
7157 sort_by_digest = sort_by_digest_4_5;
7158 opti_type = OPTI_TYPE_ZERO_BYTE
7159 | OPTI_TYPE_PRECOMPUTE_INIT
7160 | OPTI_TYPE_PRECOMPUTE_MERKLE
7161 | OPTI_TYPE_EARLY_SKIP
7162 | OPTI_TYPE_NOT_ITERATED
7163 | OPTI_TYPE_PREPENDED_SALT
7164 | OPTI_TYPE_RAW_HASH;
7165 dgst_pos0 = 3;
7166 dgst_pos1 = 4;
7167 dgst_pos2 = 2;
7168 dgst_pos3 = 1;
7169 break;
7170
7171 case 121: hash_type = HASH_TYPE_SHA1;
7172 salt_type = SALT_TYPE_INTERN;
7173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7174 opts_type = OPTS_TYPE_PT_GENERATE_BE
7175 | OPTS_TYPE_PT_ADD80
7176 | OPTS_TYPE_PT_ADDBITS15
7177 | OPTS_TYPE_ST_LOWER;
7178 kern_type = KERN_TYPE_SHA1_SLTPW;
7179 dgst_size = DGST_SIZE_4_5;
7180 parse_func = smf_parse_hash;
7181 sort_by_digest = sort_by_digest_4_5;
7182 opti_type = OPTI_TYPE_ZERO_BYTE
7183 | OPTI_TYPE_PRECOMPUTE_INIT
7184 | OPTI_TYPE_PRECOMPUTE_MERKLE
7185 | OPTI_TYPE_EARLY_SKIP
7186 | OPTI_TYPE_NOT_ITERATED
7187 | OPTI_TYPE_PREPENDED_SALT
7188 | OPTI_TYPE_RAW_HASH;
7189 dgst_pos0 = 3;
7190 dgst_pos1 = 4;
7191 dgst_pos2 = 2;
7192 dgst_pos3 = 1;
7193 break;
7194
7195 case 122: hash_type = HASH_TYPE_SHA1;
7196 salt_type = SALT_TYPE_EMBEDDED;
7197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7198 opts_type = OPTS_TYPE_PT_GENERATE_BE
7199 | OPTS_TYPE_PT_ADD80
7200 | OPTS_TYPE_PT_ADDBITS15
7201 | OPTS_TYPE_ST_HEX;
7202 kern_type = KERN_TYPE_SHA1_SLTPW;
7203 dgst_size = DGST_SIZE_4_5;
7204 parse_func = osx1_parse_hash;
7205 sort_by_digest = sort_by_digest_4_5;
7206 opti_type = OPTI_TYPE_ZERO_BYTE
7207 | OPTI_TYPE_PRECOMPUTE_INIT
7208 | OPTI_TYPE_PRECOMPUTE_MERKLE
7209 | OPTI_TYPE_EARLY_SKIP
7210 | OPTI_TYPE_NOT_ITERATED
7211 | OPTI_TYPE_PREPENDED_SALT
7212 | OPTI_TYPE_RAW_HASH;
7213 dgst_pos0 = 3;
7214 dgst_pos1 = 4;
7215 dgst_pos2 = 2;
7216 dgst_pos3 = 1;
7217 break;
7218
7219 case 124: hash_type = HASH_TYPE_SHA1;
7220 salt_type = SALT_TYPE_EMBEDDED;
7221 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7222 opts_type = OPTS_TYPE_PT_GENERATE_BE
7223 | OPTS_TYPE_PT_ADD80
7224 | OPTS_TYPE_PT_ADDBITS15;
7225 kern_type = KERN_TYPE_SHA1_SLTPW;
7226 dgst_size = DGST_SIZE_4_5;
7227 parse_func = djangosha1_parse_hash;
7228 sort_by_digest = sort_by_digest_4_5;
7229 opti_type = OPTI_TYPE_ZERO_BYTE
7230 | OPTI_TYPE_PRECOMPUTE_INIT
7231 | OPTI_TYPE_PRECOMPUTE_MERKLE
7232 | OPTI_TYPE_EARLY_SKIP
7233 | OPTI_TYPE_NOT_ITERATED
7234 | OPTI_TYPE_PREPENDED_SALT
7235 | OPTI_TYPE_RAW_HASH;
7236 dgst_pos0 = 3;
7237 dgst_pos1 = 4;
7238 dgst_pos2 = 2;
7239 dgst_pos3 = 1;
7240 break;
7241
7242 case 125: hash_type = HASH_TYPE_SHA1;
7243 salt_type = SALT_TYPE_EMBEDDED;
7244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7245 opts_type = OPTS_TYPE_PT_GENERATE_BE
7246 | OPTS_TYPE_PT_ADD80
7247 | OPTS_TYPE_PT_ADDBITS15
7248 | OPTS_TYPE_ST_HEX;
7249 kern_type = KERN_TYPE_SHA1_SLTPW;
7250 dgst_size = DGST_SIZE_4_5;
7251 parse_func = arubaos_parse_hash;
7252 sort_by_digest = sort_by_digest_4_5;
7253 opti_type = OPTI_TYPE_ZERO_BYTE
7254 | OPTI_TYPE_PRECOMPUTE_INIT
7255 | OPTI_TYPE_PRECOMPUTE_MERKLE
7256 | OPTI_TYPE_EARLY_SKIP
7257 | OPTI_TYPE_NOT_ITERATED
7258 | OPTI_TYPE_PREPENDED_SALT
7259 | OPTI_TYPE_RAW_HASH;
7260 dgst_pos0 = 3;
7261 dgst_pos1 = 4;
7262 dgst_pos2 = 2;
7263 dgst_pos3 = 1;
7264 break;
7265
7266 case 130: hash_type = HASH_TYPE_SHA1;
7267 salt_type = SALT_TYPE_INTERN;
7268 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7269 opts_type = OPTS_TYPE_PT_GENERATE_BE
7270 | OPTS_TYPE_PT_UNICODE
7271 | OPTS_TYPE_ST_ADD80
7272 | OPTS_TYPE_ST_ADDBITS15;
7273 kern_type = KERN_TYPE_SHA1_PWUSLT;
7274 dgst_size = DGST_SIZE_4_5;
7275 parse_func = sha1s_parse_hash;
7276 sort_by_digest = sort_by_digest_4_5;
7277 opti_type = OPTI_TYPE_ZERO_BYTE
7278 | OPTI_TYPE_PRECOMPUTE_INIT
7279 | OPTI_TYPE_PRECOMPUTE_MERKLE
7280 | OPTI_TYPE_EARLY_SKIP
7281 | OPTI_TYPE_NOT_ITERATED
7282 | OPTI_TYPE_APPENDED_SALT
7283 | OPTI_TYPE_RAW_HASH;
7284 dgst_pos0 = 3;
7285 dgst_pos1 = 4;
7286 dgst_pos2 = 2;
7287 dgst_pos3 = 1;
7288 break;
7289
7290 case 131: hash_type = HASH_TYPE_SHA1;
7291 salt_type = SALT_TYPE_EMBEDDED;
7292 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7293 opts_type = OPTS_TYPE_PT_GENERATE_BE
7294 | OPTS_TYPE_PT_UNICODE
7295 | OPTS_TYPE_PT_UPPER
7296 | OPTS_TYPE_ST_ADD80
7297 | OPTS_TYPE_ST_ADDBITS15
7298 | OPTS_TYPE_ST_HEX;
7299 kern_type = KERN_TYPE_SHA1_PWUSLT;
7300 dgst_size = DGST_SIZE_4_5;
7301 parse_func = mssql2000_parse_hash;
7302 sort_by_digest = sort_by_digest_4_5;
7303 opti_type = OPTI_TYPE_ZERO_BYTE
7304 | OPTI_TYPE_PRECOMPUTE_INIT
7305 | OPTI_TYPE_PRECOMPUTE_MERKLE
7306 | OPTI_TYPE_EARLY_SKIP
7307 | OPTI_TYPE_NOT_ITERATED
7308 | OPTI_TYPE_APPENDED_SALT
7309 | OPTI_TYPE_RAW_HASH;
7310 dgst_pos0 = 3;
7311 dgst_pos1 = 4;
7312 dgst_pos2 = 2;
7313 dgst_pos3 = 1;
7314 break;
7315
7316 case 132: hash_type = HASH_TYPE_SHA1;
7317 salt_type = SALT_TYPE_EMBEDDED;
7318 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7319 opts_type = OPTS_TYPE_PT_GENERATE_BE
7320 | OPTS_TYPE_PT_UNICODE
7321 | OPTS_TYPE_ST_ADD80
7322 | OPTS_TYPE_ST_ADDBITS15
7323 | OPTS_TYPE_ST_HEX;
7324 kern_type = KERN_TYPE_SHA1_PWUSLT;
7325 dgst_size = DGST_SIZE_4_5;
7326 parse_func = mssql2005_parse_hash;
7327 sort_by_digest = sort_by_digest_4_5;
7328 opti_type = OPTI_TYPE_ZERO_BYTE
7329 | OPTI_TYPE_PRECOMPUTE_INIT
7330 | OPTI_TYPE_PRECOMPUTE_MERKLE
7331 | OPTI_TYPE_EARLY_SKIP
7332 | OPTI_TYPE_NOT_ITERATED
7333 | OPTI_TYPE_APPENDED_SALT
7334 | OPTI_TYPE_RAW_HASH;
7335 dgst_pos0 = 3;
7336 dgst_pos1 = 4;
7337 dgst_pos2 = 2;
7338 dgst_pos3 = 1;
7339 break;
7340
7341 case 133: hash_type = HASH_TYPE_SHA1;
7342 salt_type = SALT_TYPE_EMBEDDED;
7343 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7344 opts_type = OPTS_TYPE_PT_GENERATE_BE
7345 | OPTS_TYPE_PT_UNICODE
7346 | OPTS_TYPE_ST_ADD80
7347 | OPTS_TYPE_ST_ADDBITS15;
7348 kern_type = KERN_TYPE_SHA1_PWUSLT;
7349 dgst_size = DGST_SIZE_4_5;
7350 parse_func = peoplesoft_parse_hash;
7351 sort_by_digest = sort_by_digest_4_5;
7352 opti_type = OPTI_TYPE_ZERO_BYTE
7353 | OPTI_TYPE_PRECOMPUTE_INIT
7354 | OPTI_TYPE_PRECOMPUTE_MERKLE
7355 | OPTI_TYPE_EARLY_SKIP
7356 | OPTI_TYPE_NOT_ITERATED
7357 | OPTI_TYPE_APPENDED_SALT
7358 | OPTI_TYPE_RAW_HASH;
7359 dgst_pos0 = 3;
7360 dgst_pos1 = 4;
7361 dgst_pos2 = 2;
7362 dgst_pos3 = 1;
7363 break;
7364
7365 case 140: hash_type = HASH_TYPE_SHA1;
7366 salt_type = SALT_TYPE_INTERN;
7367 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7368 opts_type = OPTS_TYPE_PT_GENERATE_BE
7369 | OPTS_TYPE_PT_ADD80
7370 | OPTS_TYPE_PT_ADDBITS15
7371 | OPTS_TYPE_PT_UNICODE;
7372 kern_type = KERN_TYPE_SHA1_SLTPWU;
7373 dgst_size = DGST_SIZE_4_5;
7374 parse_func = sha1s_parse_hash;
7375 sort_by_digest = sort_by_digest_4_5;
7376 opti_type = OPTI_TYPE_ZERO_BYTE
7377 | OPTI_TYPE_PRECOMPUTE_INIT
7378 | OPTI_TYPE_PRECOMPUTE_MERKLE
7379 | OPTI_TYPE_EARLY_SKIP
7380 | OPTI_TYPE_NOT_ITERATED
7381 | OPTI_TYPE_PREPENDED_SALT
7382 | OPTI_TYPE_RAW_HASH;
7383 dgst_pos0 = 3;
7384 dgst_pos1 = 4;
7385 dgst_pos2 = 2;
7386 dgst_pos3 = 1;
7387 break;
7388
7389 case 141: hash_type = HASH_TYPE_SHA1;
7390 salt_type = SALT_TYPE_EMBEDDED;
7391 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7392 opts_type = OPTS_TYPE_PT_GENERATE_BE
7393 | OPTS_TYPE_PT_ADD80
7394 | OPTS_TYPE_PT_ADDBITS15
7395 | OPTS_TYPE_PT_UNICODE
7396 | OPTS_TYPE_ST_BASE64;
7397 kern_type = KERN_TYPE_SHA1_SLTPWU;
7398 dgst_size = DGST_SIZE_4_5;
7399 parse_func = episerver_parse_hash;
7400 sort_by_digest = sort_by_digest_4_5;
7401 opti_type = OPTI_TYPE_ZERO_BYTE
7402 | OPTI_TYPE_PRECOMPUTE_INIT
7403 | OPTI_TYPE_PRECOMPUTE_MERKLE
7404 | OPTI_TYPE_EARLY_SKIP
7405 | OPTI_TYPE_NOT_ITERATED
7406 | OPTI_TYPE_PREPENDED_SALT
7407 | OPTI_TYPE_RAW_HASH;
7408 dgst_pos0 = 3;
7409 dgst_pos1 = 4;
7410 dgst_pos2 = 2;
7411 dgst_pos3 = 1;
7412 break;
7413
7414 case 150: hash_type = HASH_TYPE_SHA1;
7415 salt_type = SALT_TYPE_INTERN;
7416 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7417 opts_type = OPTS_TYPE_PT_GENERATE_BE
7418 | OPTS_TYPE_ST_ADD80
7419 | OPTS_TYPE_ST_ADDBITS15;
7420 kern_type = KERN_TYPE_HMACSHA1_PW;
7421 dgst_size = DGST_SIZE_4_5;
7422 parse_func = hmacsha1_parse_hash;
7423 sort_by_digest = sort_by_digest_4_5;
7424 opti_type = OPTI_TYPE_ZERO_BYTE
7425 | OPTI_TYPE_NOT_ITERATED;
7426 dgst_pos0 = 3;
7427 dgst_pos1 = 4;
7428 dgst_pos2 = 2;
7429 dgst_pos3 = 1;
7430 break;
7431
7432 case 160: hash_type = HASH_TYPE_SHA1;
7433 salt_type = SALT_TYPE_INTERN;
7434 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7435 opts_type = OPTS_TYPE_PT_GENERATE_BE
7436 | OPTS_TYPE_PT_ADD80
7437 | OPTS_TYPE_PT_ADDBITS15;
7438 kern_type = KERN_TYPE_HMACSHA1_SLT;
7439 dgst_size = DGST_SIZE_4_5;
7440 parse_func = hmacsha1_parse_hash;
7441 sort_by_digest = sort_by_digest_4_5;
7442 opti_type = OPTI_TYPE_ZERO_BYTE
7443 | OPTI_TYPE_NOT_ITERATED;
7444 dgst_pos0 = 3;
7445 dgst_pos1 = 4;
7446 dgst_pos2 = 2;
7447 dgst_pos3 = 1;
7448 break;
7449
7450 case 190: hash_type = HASH_TYPE_SHA1;
7451 salt_type = SALT_TYPE_NONE;
7452 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7453 opts_type = OPTS_TYPE_PT_GENERATE_BE
7454 | OPTS_TYPE_PT_ADD80
7455 | OPTS_TYPE_PT_ADDBITS15;
7456 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7457 dgst_size = DGST_SIZE_4_5;
7458 parse_func = sha1linkedin_parse_hash;
7459 sort_by_digest = sort_by_digest_4_5;
7460 opti_type = OPTI_TYPE_ZERO_BYTE
7461 | OPTI_TYPE_PRECOMPUTE_INIT
7462 | OPTI_TYPE_EARLY_SKIP
7463 | OPTI_TYPE_NOT_ITERATED
7464 | OPTI_TYPE_NOT_SALTED;
7465 dgst_pos0 = 0;
7466 dgst_pos1 = 4;
7467 dgst_pos2 = 3;
7468 dgst_pos3 = 2;
7469 break;
7470
7471 case 200: hash_type = HASH_TYPE_MYSQL;
7472 salt_type = SALT_TYPE_NONE;
7473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7474 opts_type = 0;
7475 kern_type = KERN_TYPE_MYSQL;
7476 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7477 parse_func = mysql323_parse_hash;
7478 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7479 opti_type = OPTI_TYPE_ZERO_BYTE;
7480 dgst_pos0 = 0;
7481 dgst_pos1 = 1;
7482 dgst_pos2 = 2;
7483 dgst_pos3 = 3;
7484 break;
7485
7486 case 300: hash_type = HASH_TYPE_SHA1;
7487 salt_type = SALT_TYPE_NONE;
7488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7489 opts_type = OPTS_TYPE_PT_GENERATE_BE
7490 | OPTS_TYPE_PT_ADD80
7491 | OPTS_TYPE_PT_ADDBITS15;
7492 kern_type = KERN_TYPE_MYSQL41;
7493 dgst_size = DGST_SIZE_4_5;
7494 parse_func = sha1_parse_hash;
7495 sort_by_digest = sort_by_digest_4_5;
7496 opti_type = OPTI_TYPE_ZERO_BYTE
7497 | OPTI_TYPE_PRECOMPUTE_INIT
7498 | OPTI_TYPE_PRECOMPUTE_MERKLE
7499 | OPTI_TYPE_EARLY_SKIP
7500 | OPTI_TYPE_NOT_ITERATED
7501 | OPTI_TYPE_NOT_SALTED;
7502 dgst_pos0 = 3;
7503 dgst_pos1 = 4;
7504 dgst_pos2 = 2;
7505 dgst_pos3 = 1;
7506 break;
7507
7508 case 400: hash_type = HASH_TYPE_MD5;
7509 salt_type = SALT_TYPE_EMBEDDED;
7510 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7511 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7512 kern_type = KERN_TYPE_PHPASS;
7513 dgst_size = DGST_SIZE_4_4;
7514 parse_func = phpass_parse_hash;
7515 sort_by_digest = sort_by_digest_4_4;
7516 opti_type = OPTI_TYPE_ZERO_BYTE
7517 | OPTI_TYPE_SLOW_HASH_SIMD;
7518 dgst_pos0 = 0;
7519 dgst_pos1 = 1;
7520 dgst_pos2 = 2;
7521 dgst_pos3 = 3;
7522 break;
7523
7524 case 500: hash_type = HASH_TYPE_MD5;
7525 salt_type = SALT_TYPE_EMBEDDED;
7526 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7527 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7528 kern_type = KERN_TYPE_MD5CRYPT;
7529 dgst_size = DGST_SIZE_4_4;
7530 parse_func = md5crypt_parse_hash;
7531 sort_by_digest = sort_by_digest_4_4;
7532 opti_type = OPTI_TYPE_ZERO_BYTE;
7533 dgst_pos0 = 0;
7534 dgst_pos1 = 1;
7535 dgst_pos2 = 2;
7536 dgst_pos3 = 3;
7537 break;
7538
7539 case 501: hash_type = HASH_TYPE_MD5;
7540 salt_type = SALT_TYPE_EMBEDDED;
7541 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7542 opts_type = OPTS_TYPE_PT_GENERATE_LE
7543 | OPTS_TYPE_HASH_COPY;
7544 kern_type = KERN_TYPE_MD5CRYPT;
7545 dgst_size = DGST_SIZE_4_4;
7546 parse_func = juniper_parse_hash;
7547 sort_by_digest = sort_by_digest_4_4;
7548 opti_type = OPTI_TYPE_ZERO_BYTE;
7549 dgst_pos0 = 0;
7550 dgst_pos1 = 1;
7551 dgst_pos2 = 2;
7552 dgst_pos3 = 3;
7553 break;
7554
7555 case 900: hash_type = HASH_TYPE_MD4;
7556 salt_type = SALT_TYPE_NONE;
7557 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7558 opts_type = OPTS_TYPE_PT_GENERATE_LE
7559 | OPTS_TYPE_PT_ADD80
7560 | OPTS_TYPE_PT_ADDBITS14;
7561 kern_type = KERN_TYPE_MD4;
7562 dgst_size = DGST_SIZE_4_4;
7563 parse_func = md4_parse_hash;
7564 sort_by_digest = sort_by_digest_4_4;
7565 opti_type = OPTI_TYPE_ZERO_BYTE
7566 | OPTI_TYPE_PRECOMPUTE_INIT
7567 | OPTI_TYPE_PRECOMPUTE_MERKLE
7568 | OPTI_TYPE_MEET_IN_MIDDLE
7569 | OPTI_TYPE_EARLY_SKIP
7570 | OPTI_TYPE_NOT_ITERATED
7571 | OPTI_TYPE_NOT_SALTED
7572 | OPTI_TYPE_RAW_HASH;
7573 dgst_pos0 = 0;
7574 dgst_pos1 = 3;
7575 dgst_pos2 = 2;
7576 dgst_pos3 = 1;
7577 break;
7578
7579 case 1000: hash_type = HASH_TYPE_MD4;
7580 salt_type = SALT_TYPE_NONE;
7581 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7582 opts_type = OPTS_TYPE_PT_GENERATE_LE
7583 | OPTS_TYPE_PT_ADD80
7584 | OPTS_TYPE_PT_ADDBITS14
7585 | OPTS_TYPE_PT_UNICODE;
7586 kern_type = KERN_TYPE_MD4_PWU;
7587 dgst_size = DGST_SIZE_4_4;
7588 parse_func = md4_parse_hash;
7589 sort_by_digest = sort_by_digest_4_4;
7590 opti_type = OPTI_TYPE_ZERO_BYTE
7591 | OPTI_TYPE_PRECOMPUTE_INIT
7592 | OPTI_TYPE_PRECOMPUTE_MERKLE
7593 | OPTI_TYPE_MEET_IN_MIDDLE
7594 | OPTI_TYPE_EARLY_SKIP
7595 | OPTI_TYPE_NOT_ITERATED
7596 | OPTI_TYPE_NOT_SALTED
7597 | OPTI_TYPE_RAW_HASH;
7598 dgst_pos0 = 0;
7599 dgst_pos1 = 3;
7600 dgst_pos2 = 2;
7601 dgst_pos3 = 1;
7602 break;
7603
7604 case 1100: hash_type = HASH_TYPE_MD4;
7605 salt_type = SALT_TYPE_INTERN;
7606 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7607 opts_type = OPTS_TYPE_PT_GENERATE_LE
7608 | OPTS_TYPE_PT_ADD80
7609 | OPTS_TYPE_PT_ADDBITS14
7610 | OPTS_TYPE_PT_UNICODE
7611 | OPTS_TYPE_ST_ADD80
7612 | OPTS_TYPE_ST_UNICODE
7613 | OPTS_TYPE_ST_LOWER;
7614 kern_type = KERN_TYPE_MD44_PWUSLT;
7615 dgst_size = DGST_SIZE_4_4;
7616 parse_func = dcc_parse_hash;
7617 sort_by_digest = sort_by_digest_4_4;
7618 opti_type = OPTI_TYPE_ZERO_BYTE
7619 | OPTI_TYPE_PRECOMPUTE_INIT
7620 | OPTI_TYPE_PRECOMPUTE_MERKLE
7621 | OPTI_TYPE_EARLY_SKIP
7622 | OPTI_TYPE_NOT_ITERATED;
7623 dgst_pos0 = 0;
7624 dgst_pos1 = 3;
7625 dgst_pos2 = 2;
7626 dgst_pos3 = 1;
7627 break;
7628
7629 case 1400: hash_type = HASH_TYPE_SHA256;
7630 salt_type = SALT_TYPE_NONE;
7631 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7632 opts_type = OPTS_TYPE_PT_GENERATE_BE
7633 | OPTS_TYPE_PT_ADD80
7634 | OPTS_TYPE_PT_ADDBITS15;
7635 kern_type = KERN_TYPE_SHA256;
7636 dgst_size = DGST_SIZE_4_8;
7637 parse_func = sha256_parse_hash;
7638 sort_by_digest = sort_by_digest_4_8;
7639 opti_type = OPTI_TYPE_ZERO_BYTE
7640 | OPTI_TYPE_PRECOMPUTE_INIT
7641 | OPTI_TYPE_PRECOMPUTE_MERKLE
7642 | OPTI_TYPE_EARLY_SKIP
7643 | OPTI_TYPE_NOT_ITERATED
7644 | OPTI_TYPE_NOT_SALTED
7645 | OPTI_TYPE_RAW_HASH;
7646 dgst_pos0 = 3;
7647 dgst_pos1 = 7;
7648 dgst_pos2 = 2;
7649 dgst_pos3 = 6;
7650 break;
7651
7652 case 1410: hash_type = HASH_TYPE_SHA256;
7653 salt_type = SALT_TYPE_INTERN;
7654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7655 opts_type = OPTS_TYPE_PT_GENERATE_BE
7656 | OPTS_TYPE_ST_ADD80
7657 | OPTS_TYPE_ST_ADDBITS15;
7658 kern_type = KERN_TYPE_SHA256_PWSLT;
7659 dgst_size = DGST_SIZE_4_8;
7660 parse_func = sha256s_parse_hash;
7661 sort_by_digest = sort_by_digest_4_8;
7662 opti_type = OPTI_TYPE_ZERO_BYTE
7663 | OPTI_TYPE_PRECOMPUTE_INIT
7664 | OPTI_TYPE_PRECOMPUTE_MERKLE
7665 | OPTI_TYPE_EARLY_SKIP
7666 | OPTI_TYPE_NOT_ITERATED
7667 | OPTI_TYPE_APPENDED_SALT
7668 | OPTI_TYPE_RAW_HASH;
7669 dgst_pos0 = 3;
7670 dgst_pos1 = 7;
7671 dgst_pos2 = 2;
7672 dgst_pos3 = 6;
7673 break;
7674
7675 case 1420: hash_type = HASH_TYPE_SHA256;
7676 salt_type = SALT_TYPE_INTERN;
7677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7678 opts_type = OPTS_TYPE_PT_GENERATE_BE
7679 | OPTS_TYPE_PT_ADD80
7680 | OPTS_TYPE_PT_ADDBITS15;
7681 kern_type = KERN_TYPE_SHA256_SLTPW;
7682 dgst_size = DGST_SIZE_4_8;
7683 parse_func = sha256s_parse_hash;
7684 sort_by_digest = sort_by_digest_4_8;
7685 opti_type = OPTI_TYPE_ZERO_BYTE
7686 | OPTI_TYPE_PRECOMPUTE_INIT
7687 | OPTI_TYPE_PRECOMPUTE_MERKLE
7688 | OPTI_TYPE_EARLY_SKIP
7689 | OPTI_TYPE_NOT_ITERATED
7690 | OPTI_TYPE_PREPENDED_SALT
7691 | OPTI_TYPE_RAW_HASH;
7692 dgst_pos0 = 3;
7693 dgst_pos1 = 7;
7694 dgst_pos2 = 2;
7695 dgst_pos3 = 6;
7696 break;
7697
7698 case 1421: hash_type = HASH_TYPE_SHA256;
7699 salt_type = SALT_TYPE_EMBEDDED;
7700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7701 opts_type = OPTS_TYPE_PT_GENERATE_BE
7702 | OPTS_TYPE_PT_ADD80
7703 | OPTS_TYPE_PT_ADDBITS15;
7704 kern_type = KERN_TYPE_SHA256_SLTPW;
7705 dgst_size = DGST_SIZE_4_8;
7706 parse_func = hmailserver_parse_hash;
7707 sort_by_digest = sort_by_digest_4_8;
7708 opti_type = OPTI_TYPE_ZERO_BYTE
7709 | OPTI_TYPE_PRECOMPUTE_INIT
7710 | OPTI_TYPE_PRECOMPUTE_MERKLE
7711 | OPTI_TYPE_EARLY_SKIP
7712 | OPTI_TYPE_NOT_ITERATED
7713 | OPTI_TYPE_PREPENDED_SALT
7714 | OPTI_TYPE_RAW_HASH;
7715 dgst_pos0 = 3;
7716 dgst_pos1 = 7;
7717 dgst_pos2 = 2;
7718 dgst_pos3 = 6;
7719 break;
7720
7721 case 1430: hash_type = HASH_TYPE_SHA256;
7722 salt_type = SALT_TYPE_INTERN;
7723 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7724 opts_type = OPTS_TYPE_PT_GENERATE_BE
7725 | OPTS_TYPE_PT_UNICODE
7726 | OPTS_TYPE_ST_ADD80
7727 | OPTS_TYPE_ST_ADDBITS15;
7728 kern_type = KERN_TYPE_SHA256_PWUSLT;
7729 dgst_size = DGST_SIZE_4_8;
7730 parse_func = sha256s_parse_hash;
7731 sort_by_digest = sort_by_digest_4_8;
7732 opti_type = OPTI_TYPE_ZERO_BYTE
7733 | OPTI_TYPE_PRECOMPUTE_INIT
7734 | OPTI_TYPE_PRECOMPUTE_MERKLE
7735 | OPTI_TYPE_EARLY_SKIP
7736 | OPTI_TYPE_NOT_ITERATED
7737 | OPTI_TYPE_APPENDED_SALT
7738 | OPTI_TYPE_RAW_HASH;
7739 dgst_pos0 = 3;
7740 dgst_pos1 = 7;
7741 dgst_pos2 = 2;
7742 dgst_pos3 = 6;
7743 break;
7744
7745 case 1440: hash_type = HASH_TYPE_SHA256;
7746 salt_type = SALT_TYPE_INTERN;
7747 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7748 opts_type = OPTS_TYPE_PT_GENERATE_BE
7749 | OPTS_TYPE_PT_ADD80
7750 | OPTS_TYPE_PT_ADDBITS15
7751 | OPTS_TYPE_PT_UNICODE;
7752 kern_type = KERN_TYPE_SHA256_SLTPWU;
7753 dgst_size = DGST_SIZE_4_8;
7754 parse_func = sha256s_parse_hash;
7755 sort_by_digest = sort_by_digest_4_8;
7756 opti_type = OPTI_TYPE_ZERO_BYTE
7757 | OPTI_TYPE_PRECOMPUTE_INIT
7758 | OPTI_TYPE_PRECOMPUTE_MERKLE
7759 | OPTI_TYPE_EARLY_SKIP
7760 | OPTI_TYPE_NOT_ITERATED
7761 | OPTI_TYPE_PREPENDED_SALT
7762 | OPTI_TYPE_RAW_HASH;
7763 dgst_pos0 = 3;
7764 dgst_pos1 = 7;
7765 dgst_pos2 = 2;
7766 dgst_pos3 = 6;
7767 break;
7768
7769 case 1441: hash_type = HASH_TYPE_SHA256;
7770 salt_type = SALT_TYPE_EMBEDDED;
7771 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7772 opts_type = OPTS_TYPE_PT_GENERATE_BE
7773 | OPTS_TYPE_PT_ADD80
7774 | OPTS_TYPE_PT_ADDBITS15
7775 | OPTS_TYPE_PT_UNICODE
7776 | OPTS_TYPE_ST_BASE64;
7777 kern_type = KERN_TYPE_SHA256_SLTPWU;
7778 dgst_size = DGST_SIZE_4_8;
7779 parse_func = episerver4_parse_hash;
7780 sort_by_digest = sort_by_digest_4_8;
7781 opti_type = OPTI_TYPE_ZERO_BYTE
7782 | OPTI_TYPE_PRECOMPUTE_INIT
7783 | OPTI_TYPE_PRECOMPUTE_MERKLE
7784 | OPTI_TYPE_EARLY_SKIP
7785 | OPTI_TYPE_NOT_ITERATED
7786 | OPTI_TYPE_PREPENDED_SALT
7787 | OPTI_TYPE_RAW_HASH;
7788 dgst_pos0 = 3;
7789 dgst_pos1 = 7;
7790 dgst_pos2 = 2;
7791 dgst_pos3 = 6;
7792 break;
7793
7794 case 1450: hash_type = HASH_TYPE_SHA256;
7795 salt_type = SALT_TYPE_INTERN;
7796 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7797 opts_type = OPTS_TYPE_PT_GENERATE_BE
7798 | OPTS_TYPE_ST_ADD80;
7799 kern_type = KERN_TYPE_HMACSHA256_PW;
7800 dgst_size = DGST_SIZE_4_8;
7801 parse_func = hmacsha256_parse_hash;
7802 sort_by_digest = sort_by_digest_4_8;
7803 opti_type = OPTI_TYPE_ZERO_BYTE
7804 | OPTI_TYPE_NOT_ITERATED;
7805 dgst_pos0 = 3;
7806 dgst_pos1 = 7;
7807 dgst_pos2 = 2;
7808 dgst_pos3 = 6;
7809 break;
7810
7811 case 1460: hash_type = HASH_TYPE_SHA256;
7812 salt_type = SALT_TYPE_INTERN;
7813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7814 opts_type = OPTS_TYPE_PT_GENERATE_BE
7815 | OPTS_TYPE_PT_ADD80
7816 | OPTS_TYPE_PT_ADDBITS15;
7817 kern_type = KERN_TYPE_HMACSHA256_SLT;
7818 dgst_size = DGST_SIZE_4_8;
7819 parse_func = hmacsha256_parse_hash;
7820 sort_by_digest = sort_by_digest_4_8;
7821 opti_type = OPTI_TYPE_ZERO_BYTE
7822 | OPTI_TYPE_NOT_ITERATED;
7823 dgst_pos0 = 3;
7824 dgst_pos1 = 7;
7825 dgst_pos2 = 2;
7826 dgst_pos3 = 6;
7827 break;
7828
7829 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7830 salt_type = SALT_TYPE_EMBEDDED;
7831 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7832 opts_type = OPTS_TYPE_PT_GENERATE_LE
7833 | OPTS_TYPE_PT_BITSLICE;
7834 kern_type = KERN_TYPE_DESCRYPT;
7835 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7836 parse_func = descrypt_parse_hash;
7837 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7838 opti_type = OPTI_TYPE_ZERO_BYTE
7839 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7840 dgst_pos0 = 0;
7841 dgst_pos1 = 1;
7842 dgst_pos2 = 2;
7843 dgst_pos3 = 3;
7844 break;
7845
7846 case 1600: hash_type = HASH_TYPE_MD5;
7847 salt_type = SALT_TYPE_EMBEDDED;
7848 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7849 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7850 kern_type = KERN_TYPE_APR1CRYPT;
7851 dgst_size = DGST_SIZE_4_4;
7852 parse_func = md5apr1_parse_hash;
7853 sort_by_digest = sort_by_digest_4_4;
7854 opti_type = OPTI_TYPE_ZERO_BYTE;
7855 dgst_pos0 = 0;
7856 dgst_pos1 = 1;
7857 dgst_pos2 = 2;
7858 dgst_pos3 = 3;
7859 break;
7860
7861 case 1700: hash_type = HASH_TYPE_SHA512;
7862 salt_type = SALT_TYPE_NONE;
7863 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7864 opts_type = OPTS_TYPE_PT_GENERATE_BE
7865 | OPTS_TYPE_PT_ADD80
7866 | OPTS_TYPE_PT_ADDBITS15;
7867 kern_type = KERN_TYPE_SHA512;
7868 dgst_size = DGST_SIZE_8_8;
7869 parse_func = sha512_parse_hash;
7870 sort_by_digest = sort_by_digest_8_8;
7871 opti_type = OPTI_TYPE_ZERO_BYTE
7872 | OPTI_TYPE_PRECOMPUTE_INIT
7873 | OPTI_TYPE_PRECOMPUTE_MERKLE
7874 | OPTI_TYPE_EARLY_SKIP
7875 | OPTI_TYPE_NOT_ITERATED
7876 | OPTI_TYPE_NOT_SALTED
7877 | OPTI_TYPE_USES_BITS_64
7878 | OPTI_TYPE_RAW_HASH;
7879 dgst_pos0 = 14;
7880 dgst_pos1 = 15;
7881 dgst_pos2 = 6;
7882 dgst_pos3 = 7;
7883 break;
7884
7885 case 1710: hash_type = HASH_TYPE_SHA512;
7886 salt_type = SALT_TYPE_INTERN;
7887 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7888 opts_type = OPTS_TYPE_PT_GENERATE_BE
7889 | OPTS_TYPE_ST_ADD80
7890 | OPTS_TYPE_ST_ADDBITS15;
7891 kern_type = KERN_TYPE_SHA512_PWSLT;
7892 dgst_size = DGST_SIZE_8_8;
7893 parse_func = sha512s_parse_hash;
7894 sort_by_digest = sort_by_digest_8_8;
7895 opti_type = OPTI_TYPE_ZERO_BYTE
7896 | OPTI_TYPE_PRECOMPUTE_INIT
7897 | OPTI_TYPE_PRECOMPUTE_MERKLE
7898 | OPTI_TYPE_EARLY_SKIP
7899 | OPTI_TYPE_NOT_ITERATED
7900 | OPTI_TYPE_APPENDED_SALT
7901 | OPTI_TYPE_USES_BITS_64
7902 | OPTI_TYPE_RAW_HASH;
7903 dgst_pos0 = 14;
7904 dgst_pos1 = 15;
7905 dgst_pos2 = 6;
7906 dgst_pos3 = 7;
7907 break;
7908
7909 case 1711: hash_type = HASH_TYPE_SHA512;
7910 salt_type = SALT_TYPE_EMBEDDED;
7911 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7912 opts_type = OPTS_TYPE_PT_GENERATE_BE
7913 | OPTS_TYPE_ST_ADD80
7914 | OPTS_TYPE_ST_ADDBITS15;
7915 kern_type = KERN_TYPE_SHA512_PWSLT;
7916 dgst_size = DGST_SIZE_8_8;
7917 parse_func = sha512b64s_parse_hash;
7918 sort_by_digest = sort_by_digest_8_8;
7919 opti_type = OPTI_TYPE_ZERO_BYTE
7920 | OPTI_TYPE_PRECOMPUTE_INIT
7921 | OPTI_TYPE_PRECOMPUTE_MERKLE
7922 | OPTI_TYPE_EARLY_SKIP
7923 | OPTI_TYPE_NOT_ITERATED
7924 | OPTI_TYPE_APPENDED_SALT
7925 | OPTI_TYPE_USES_BITS_64
7926 | OPTI_TYPE_RAW_HASH;
7927 dgst_pos0 = 14;
7928 dgst_pos1 = 15;
7929 dgst_pos2 = 6;
7930 dgst_pos3 = 7;
7931 break;
7932
7933 case 1720: hash_type = HASH_TYPE_SHA512;
7934 salt_type = SALT_TYPE_INTERN;
7935 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7936 opts_type = OPTS_TYPE_PT_GENERATE_BE
7937 | OPTS_TYPE_PT_ADD80
7938 | OPTS_TYPE_PT_ADDBITS15;
7939 kern_type = KERN_TYPE_SHA512_SLTPW;
7940 dgst_size = DGST_SIZE_8_8;
7941 parse_func = sha512s_parse_hash;
7942 sort_by_digest = sort_by_digest_8_8;
7943 opti_type = OPTI_TYPE_ZERO_BYTE
7944 | OPTI_TYPE_PRECOMPUTE_INIT
7945 | OPTI_TYPE_PRECOMPUTE_MERKLE
7946 | OPTI_TYPE_EARLY_SKIP
7947 | OPTI_TYPE_NOT_ITERATED
7948 | OPTI_TYPE_PREPENDED_SALT
7949 | OPTI_TYPE_USES_BITS_64
7950 | OPTI_TYPE_RAW_HASH;
7951 dgst_pos0 = 14;
7952 dgst_pos1 = 15;
7953 dgst_pos2 = 6;
7954 dgst_pos3 = 7;
7955 break;
7956
7957 case 1722: hash_type = HASH_TYPE_SHA512;
7958 salt_type = SALT_TYPE_EMBEDDED;
7959 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7960 opts_type = OPTS_TYPE_PT_GENERATE_BE
7961 | OPTS_TYPE_PT_ADD80
7962 | OPTS_TYPE_PT_ADDBITS15
7963 | OPTS_TYPE_ST_HEX;
7964 kern_type = KERN_TYPE_SHA512_SLTPW;
7965 dgst_size = DGST_SIZE_8_8;
7966 parse_func = osx512_parse_hash;
7967 sort_by_digest = sort_by_digest_8_8;
7968 opti_type = OPTI_TYPE_ZERO_BYTE
7969 | OPTI_TYPE_PRECOMPUTE_INIT
7970 | OPTI_TYPE_PRECOMPUTE_MERKLE
7971 | OPTI_TYPE_EARLY_SKIP
7972 | OPTI_TYPE_NOT_ITERATED
7973 | OPTI_TYPE_PREPENDED_SALT
7974 | OPTI_TYPE_USES_BITS_64
7975 | OPTI_TYPE_RAW_HASH;
7976 dgst_pos0 = 14;
7977 dgst_pos1 = 15;
7978 dgst_pos2 = 6;
7979 dgst_pos3 = 7;
7980 break;
7981
7982 case 1730: hash_type = HASH_TYPE_SHA512;
7983 salt_type = SALT_TYPE_INTERN;
7984 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7985 opts_type = OPTS_TYPE_PT_GENERATE_BE
7986 | OPTS_TYPE_PT_UNICODE
7987 | OPTS_TYPE_ST_ADD80
7988 | OPTS_TYPE_ST_ADDBITS15;
7989 kern_type = KERN_TYPE_SHA512_PWSLTU;
7990 dgst_size = DGST_SIZE_8_8;
7991 parse_func = sha512s_parse_hash;
7992 sort_by_digest = sort_by_digest_8_8;
7993 opti_type = OPTI_TYPE_ZERO_BYTE
7994 | OPTI_TYPE_PRECOMPUTE_INIT
7995 | OPTI_TYPE_PRECOMPUTE_MERKLE
7996 | OPTI_TYPE_EARLY_SKIP
7997 | OPTI_TYPE_NOT_ITERATED
7998 | OPTI_TYPE_APPENDED_SALT
7999 | OPTI_TYPE_USES_BITS_64
8000 | OPTI_TYPE_RAW_HASH;
8001 dgst_pos0 = 14;
8002 dgst_pos1 = 15;
8003 dgst_pos2 = 6;
8004 dgst_pos3 = 7;
8005 break;
8006
8007 case 1731: hash_type = HASH_TYPE_SHA512;
8008 salt_type = SALT_TYPE_EMBEDDED;
8009 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8010 opts_type = OPTS_TYPE_PT_GENERATE_BE
8011 | OPTS_TYPE_PT_UNICODE
8012 | OPTS_TYPE_ST_ADD80
8013 | OPTS_TYPE_ST_ADDBITS15
8014 | OPTS_TYPE_ST_HEX;
8015 kern_type = KERN_TYPE_SHA512_PWSLTU;
8016 dgst_size = DGST_SIZE_8_8;
8017 parse_func = mssql2012_parse_hash;
8018 sort_by_digest = sort_by_digest_8_8;
8019 opti_type = OPTI_TYPE_ZERO_BYTE
8020 | OPTI_TYPE_PRECOMPUTE_INIT
8021 | OPTI_TYPE_PRECOMPUTE_MERKLE
8022 | OPTI_TYPE_EARLY_SKIP
8023 | OPTI_TYPE_NOT_ITERATED
8024 | OPTI_TYPE_APPENDED_SALT
8025 | OPTI_TYPE_USES_BITS_64
8026 | OPTI_TYPE_RAW_HASH;
8027 dgst_pos0 = 14;
8028 dgst_pos1 = 15;
8029 dgst_pos2 = 6;
8030 dgst_pos3 = 7;
8031 break;
8032
8033 case 1740: hash_type = HASH_TYPE_SHA512;
8034 salt_type = SALT_TYPE_INTERN;
8035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8036 opts_type = OPTS_TYPE_PT_GENERATE_BE
8037 | OPTS_TYPE_PT_ADD80
8038 | OPTS_TYPE_PT_ADDBITS15
8039 | OPTS_TYPE_PT_UNICODE;
8040 kern_type = KERN_TYPE_SHA512_SLTPWU;
8041 dgst_size = DGST_SIZE_8_8;
8042 parse_func = sha512s_parse_hash;
8043 sort_by_digest = sort_by_digest_8_8;
8044 opti_type = OPTI_TYPE_ZERO_BYTE
8045 | OPTI_TYPE_PRECOMPUTE_INIT
8046 | OPTI_TYPE_PRECOMPUTE_MERKLE
8047 | OPTI_TYPE_EARLY_SKIP
8048 | OPTI_TYPE_NOT_ITERATED
8049 | OPTI_TYPE_PREPENDED_SALT
8050 | OPTI_TYPE_USES_BITS_64
8051 | OPTI_TYPE_RAW_HASH;
8052 dgst_pos0 = 14;
8053 dgst_pos1 = 15;
8054 dgst_pos2 = 6;
8055 dgst_pos3 = 7;
8056 break;
8057
8058 case 1750: hash_type = HASH_TYPE_SHA512;
8059 salt_type = SALT_TYPE_INTERN;
8060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8061 opts_type = OPTS_TYPE_PT_GENERATE_BE
8062 | OPTS_TYPE_ST_ADD80;
8063 kern_type = KERN_TYPE_HMACSHA512_PW;
8064 dgst_size = DGST_SIZE_8_8;
8065 parse_func = hmacsha512_parse_hash;
8066 sort_by_digest = sort_by_digest_8_8;
8067 opti_type = OPTI_TYPE_ZERO_BYTE
8068 | OPTI_TYPE_USES_BITS_64
8069 | OPTI_TYPE_NOT_ITERATED;
8070 dgst_pos0 = 14;
8071 dgst_pos1 = 15;
8072 dgst_pos2 = 6;
8073 dgst_pos3 = 7;
8074 break;
8075
8076 case 1760: hash_type = HASH_TYPE_SHA512;
8077 salt_type = SALT_TYPE_INTERN;
8078 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8079 opts_type = OPTS_TYPE_PT_GENERATE_BE
8080 | OPTS_TYPE_PT_ADD80
8081 | OPTS_TYPE_PT_ADDBITS15;
8082 kern_type = KERN_TYPE_HMACSHA512_SLT;
8083 dgst_size = DGST_SIZE_8_8;
8084 parse_func = hmacsha512_parse_hash;
8085 sort_by_digest = sort_by_digest_8_8;
8086 opti_type = OPTI_TYPE_ZERO_BYTE
8087 | OPTI_TYPE_USES_BITS_64
8088 | OPTI_TYPE_NOT_ITERATED;
8089 dgst_pos0 = 14;
8090 dgst_pos1 = 15;
8091 dgst_pos2 = 6;
8092 dgst_pos3 = 7;
8093 break;
8094
8095 case 1800: hash_type = HASH_TYPE_SHA512;
8096 salt_type = SALT_TYPE_EMBEDDED;
8097 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8098 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8099 kern_type = KERN_TYPE_SHA512CRYPT;
8100 dgst_size = DGST_SIZE_8_8;
8101 parse_func = sha512crypt_parse_hash;
8102 sort_by_digest = sort_by_digest_8_8;
8103 opti_type = OPTI_TYPE_ZERO_BYTE
8104 | OPTI_TYPE_USES_BITS_64;
8105 dgst_pos0 = 0;
8106 dgst_pos1 = 1;
8107 dgst_pos2 = 2;
8108 dgst_pos3 = 3;
8109 break;
8110
8111 case 2100: hash_type = HASH_TYPE_DCC2;
8112 salt_type = SALT_TYPE_EMBEDDED;
8113 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8114 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8115 | OPTS_TYPE_ST_LOWER
8116 | OPTS_TYPE_ST_UNICODE;
8117 kern_type = KERN_TYPE_DCC2;
8118 dgst_size = DGST_SIZE_4_4;
8119 parse_func = dcc2_parse_hash;
8120 sort_by_digest = sort_by_digest_4_4;
8121 opti_type = OPTI_TYPE_ZERO_BYTE;
8122 dgst_pos0 = 0;
8123 dgst_pos1 = 1;
8124 dgst_pos2 = 2;
8125 dgst_pos3 = 3;
8126 break;
8127
8128 case 2400: hash_type = HASH_TYPE_MD5;
8129 salt_type = SALT_TYPE_NONE;
8130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8131 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8132 kern_type = KERN_TYPE_MD5PIX;
8133 dgst_size = DGST_SIZE_4_4;
8134 parse_func = md5pix_parse_hash;
8135 sort_by_digest = sort_by_digest_4_4;
8136 opti_type = OPTI_TYPE_ZERO_BYTE
8137 | OPTI_TYPE_PRECOMPUTE_INIT
8138 | OPTI_TYPE_PRECOMPUTE_MERKLE
8139 | OPTI_TYPE_EARLY_SKIP
8140 | OPTI_TYPE_NOT_ITERATED
8141 | OPTI_TYPE_NOT_SALTED;
8142 dgst_pos0 = 0;
8143 dgst_pos1 = 3;
8144 dgst_pos2 = 2;
8145 dgst_pos3 = 1;
8146 break;
8147
8148 case 2410: hash_type = HASH_TYPE_MD5;
8149 salt_type = SALT_TYPE_INTERN;
8150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8151 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8152 kern_type = KERN_TYPE_MD5ASA;
8153 dgst_size = DGST_SIZE_4_4;
8154 parse_func = md5asa_parse_hash;
8155 sort_by_digest = sort_by_digest_4_4;
8156 opti_type = OPTI_TYPE_ZERO_BYTE
8157 | OPTI_TYPE_PRECOMPUTE_INIT
8158 | OPTI_TYPE_PRECOMPUTE_MERKLE
8159 | OPTI_TYPE_EARLY_SKIP
8160 | OPTI_TYPE_NOT_ITERATED;
8161 dgst_pos0 = 0;
8162 dgst_pos1 = 3;
8163 dgst_pos2 = 2;
8164 dgst_pos3 = 1;
8165 break;
8166
8167 case 2500: hash_type = HASH_TYPE_WPA;
8168 salt_type = SALT_TYPE_EMBEDDED;
8169 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8170 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8171 kern_type = KERN_TYPE_WPA;
8172 dgst_size = DGST_SIZE_4_4;
8173 parse_func = wpa_parse_hash;
8174 sort_by_digest = sort_by_digest_4_4;
8175 opti_type = OPTI_TYPE_ZERO_BYTE;
8176 dgst_pos0 = 0;
8177 dgst_pos1 = 1;
8178 dgst_pos2 = 2;
8179 dgst_pos3 = 3;
8180 break;
8181
8182 case 2600: hash_type = HASH_TYPE_MD5;
8183 salt_type = SALT_TYPE_VIRTUAL;
8184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8185 opts_type = OPTS_TYPE_PT_GENERATE_LE
8186 | OPTS_TYPE_PT_ADD80
8187 | OPTS_TYPE_PT_ADDBITS14
8188 | OPTS_TYPE_ST_ADD80;
8189 kern_type = KERN_TYPE_MD55_PWSLT1;
8190 dgst_size = DGST_SIZE_4_4;
8191 parse_func = md5md5_parse_hash;
8192 sort_by_digest = sort_by_digest_4_4;
8193 opti_type = OPTI_TYPE_ZERO_BYTE
8194 | OPTI_TYPE_PRECOMPUTE_INIT
8195 | OPTI_TYPE_PRECOMPUTE_MERKLE
8196 | OPTI_TYPE_EARLY_SKIP;
8197 dgst_pos0 = 0;
8198 dgst_pos1 = 3;
8199 dgst_pos2 = 2;
8200 dgst_pos3 = 1;
8201 break;
8202
8203 case 2611: hash_type = HASH_TYPE_MD5;
8204 salt_type = SALT_TYPE_INTERN;
8205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8206 opts_type = OPTS_TYPE_PT_GENERATE_LE
8207 | OPTS_TYPE_PT_ADD80
8208 | OPTS_TYPE_PT_ADDBITS14
8209 | OPTS_TYPE_ST_ADD80;
8210 kern_type = KERN_TYPE_MD55_PWSLT1;
8211 dgst_size = DGST_SIZE_4_4;
8212 parse_func = vb3_parse_hash;
8213 sort_by_digest = sort_by_digest_4_4;
8214 opti_type = OPTI_TYPE_ZERO_BYTE
8215 | OPTI_TYPE_PRECOMPUTE_INIT
8216 | OPTI_TYPE_PRECOMPUTE_MERKLE
8217 | OPTI_TYPE_EARLY_SKIP;
8218 dgst_pos0 = 0;
8219 dgst_pos1 = 3;
8220 dgst_pos2 = 2;
8221 dgst_pos3 = 1;
8222 break;
8223
8224 case 2612: hash_type = HASH_TYPE_MD5;
8225 salt_type = SALT_TYPE_EMBEDDED;
8226 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8227 opts_type = OPTS_TYPE_PT_GENERATE_LE
8228 | OPTS_TYPE_PT_ADD80
8229 | OPTS_TYPE_PT_ADDBITS14
8230 | OPTS_TYPE_ST_ADD80
8231 | OPTS_TYPE_ST_HEX;
8232 kern_type = KERN_TYPE_MD55_PWSLT1;
8233 dgst_size = DGST_SIZE_4_4;
8234 parse_func = phps_parse_hash;
8235 sort_by_digest = sort_by_digest_4_4;
8236 opti_type = OPTI_TYPE_ZERO_BYTE
8237 | OPTI_TYPE_PRECOMPUTE_INIT
8238 | OPTI_TYPE_PRECOMPUTE_MERKLE
8239 | OPTI_TYPE_EARLY_SKIP;
8240 dgst_pos0 = 0;
8241 dgst_pos1 = 3;
8242 dgst_pos2 = 2;
8243 dgst_pos3 = 1;
8244 break;
8245
8246 case 2711: hash_type = HASH_TYPE_MD5;
8247 salt_type = SALT_TYPE_INTERN;
8248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8249 opts_type = OPTS_TYPE_PT_GENERATE_LE
8250 | OPTS_TYPE_PT_ADD80
8251 | OPTS_TYPE_PT_ADDBITS14
8252 | OPTS_TYPE_ST_ADD80;
8253 kern_type = KERN_TYPE_MD55_PWSLT2;
8254 dgst_size = DGST_SIZE_4_4;
8255 parse_func = vb30_parse_hash;
8256 sort_by_digest = sort_by_digest_4_4;
8257 opti_type = OPTI_TYPE_ZERO_BYTE
8258 | OPTI_TYPE_PRECOMPUTE_INIT
8259 | OPTI_TYPE_EARLY_SKIP;
8260 dgst_pos0 = 0;
8261 dgst_pos1 = 3;
8262 dgst_pos2 = 2;
8263 dgst_pos3 = 1;
8264 break;
8265
8266 case 2811: hash_type = HASH_TYPE_MD5;
8267 salt_type = SALT_TYPE_INTERN;
8268 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8269 opts_type = OPTS_TYPE_PT_GENERATE_LE
8270 | OPTS_TYPE_PT_ADD80
8271 | OPTS_TYPE_PT_ADDBITS14;
8272 kern_type = KERN_TYPE_MD55_SLTPW;
8273 dgst_size = DGST_SIZE_4_4;
8274 parse_func = ipb2_parse_hash;
8275 sort_by_digest = sort_by_digest_4_4;
8276 opti_type = OPTI_TYPE_ZERO_BYTE
8277 | OPTI_TYPE_PRECOMPUTE_INIT
8278 | OPTI_TYPE_EARLY_SKIP;
8279 dgst_pos0 = 0;
8280 dgst_pos1 = 3;
8281 dgst_pos2 = 2;
8282 dgst_pos3 = 1;
8283 break;
8284
8285 case 3000: hash_type = HASH_TYPE_LM;
8286 salt_type = SALT_TYPE_NONE;
8287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8288 opts_type = OPTS_TYPE_PT_GENERATE_LE
8289 | OPTS_TYPE_PT_UPPER
8290 | OPTS_TYPE_PT_BITSLICE;
8291 kern_type = KERN_TYPE_LM;
8292 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8293 parse_func = lm_parse_hash;
8294 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8295 opti_type = OPTI_TYPE_ZERO_BYTE
8296 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8297 dgst_pos0 = 0;
8298 dgst_pos1 = 1;
8299 dgst_pos2 = 2;
8300 dgst_pos3 = 3;
8301 break;
8302
8303 case 3100: hash_type = HASH_TYPE_ORACLEH;
8304 salt_type = SALT_TYPE_INTERN;
8305 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8306 opts_type = OPTS_TYPE_PT_GENERATE_LE
8307 | OPTS_TYPE_PT_UPPER
8308 | OPTS_TYPE_ST_UPPER;
8309 kern_type = KERN_TYPE_ORACLEH;
8310 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8311 parse_func = oracleh_parse_hash;
8312 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8313 opti_type = OPTI_TYPE_ZERO_BYTE;
8314 dgst_pos0 = 0;
8315 dgst_pos1 = 1;
8316 dgst_pos2 = 2;
8317 dgst_pos3 = 3;
8318 break;
8319
8320 case 3200: hash_type = HASH_TYPE_BCRYPT;
8321 salt_type = SALT_TYPE_EMBEDDED;
8322 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8323 opts_type = OPTS_TYPE_PT_GENERATE_LE
8324 | OPTS_TYPE_ST_GENERATE_LE;
8325 kern_type = KERN_TYPE_BCRYPT;
8326 dgst_size = DGST_SIZE_4_6;
8327 parse_func = bcrypt_parse_hash;
8328 sort_by_digest = sort_by_digest_4_6;
8329 opti_type = OPTI_TYPE_ZERO_BYTE;
8330 dgst_pos0 = 0;
8331 dgst_pos1 = 1;
8332 dgst_pos2 = 2;
8333 dgst_pos3 = 3;
8334 break;
8335
8336 case 3710: hash_type = HASH_TYPE_MD5;
8337 salt_type = SALT_TYPE_INTERN;
8338 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8339 opts_type = OPTS_TYPE_PT_GENERATE_LE
8340 | OPTS_TYPE_PT_ADD80
8341 | OPTS_TYPE_PT_ADDBITS14;
8342 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8343 dgst_size = DGST_SIZE_4_4;
8344 parse_func = md5s_parse_hash;
8345 sort_by_digest = sort_by_digest_4_4;
8346 opti_type = OPTI_TYPE_ZERO_BYTE
8347 | OPTI_TYPE_PRECOMPUTE_INIT
8348 | OPTI_TYPE_PRECOMPUTE_MERKLE
8349 | OPTI_TYPE_EARLY_SKIP;
8350 dgst_pos0 = 0;
8351 dgst_pos1 = 3;
8352 dgst_pos2 = 2;
8353 dgst_pos3 = 1;
8354 break;
8355
8356 case 3711: hash_type = HASH_TYPE_MD5;
8357 salt_type = SALT_TYPE_EMBEDDED;
8358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8359 opts_type = OPTS_TYPE_PT_GENERATE_LE
8360 | OPTS_TYPE_PT_ADD80
8361 | OPTS_TYPE_PT_ADDBITS14;
8362 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8363 dgst_size = DGST_SIZE_4_4;
8364 parse_func = mediawiki_b_parse_hash;
8365 sort_by_digest = sort_by_digest_4_4;
8366 opti_type = OPTI_TYPE_ZERO_BYTE
8367 | OPTI_TYPE_PRECOMPUTE_INIT
8368 | OPTI_TYPE_PRECOMPUTE_MERKLE
8369 | OPTI_TYPE_EARLY_SKIP;
8370 dgst_pos0 = 0;
8371 dgst_pos1 = 3;
8372 dgst_pos2 = 2;
8373 dgst_pos3 = 1;
8374 break;
8375
8376 case 3800: hash_type = HASH_TYPE_MD5;
8377 salt_type = SALT_TYPE_INTERN;
8378 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8379 opts_type = OPTS_TYPE_PT_GENERATE_LE
8380 | OPTS_TYPE_ST_ADDBITS14;
8381 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8382 dgst_size = DGST_SIZE_4_4;
8383 parse_func = md5s_parse_hash;
8384 sort_by_digest = sort_by_digest_4_4;
8385 opti_type = OPTI_TYPE_ZERO_BYTE
8386 | OPTI_TYPE_PRECOMPUTE_INIT
8387 | OPTI_TYPE_PRECOMPUTE_MERKLE
8388 | OPTI_TYPE_EARLY_SKIP
8389 | OPTI_TYPE_NOT_ITERATED
8390 | OPTI_TYPE_RAW_HASH;
8391 dgst_pos0 = 0;
8392 dgst_pos1 = 3;
8393 dgst_pos2 = 2;
8394 dgst_pos3 = 1;
8395 break;
8396
8397 case 4300: hash_type = HASH_TYPE_MD5;
8398 salt_type = SALT_TYPE_VIRTUAL;
8399 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8400 opts_type = OPTS_TYPE_PT_GENERATE_LE
8401 | OPTS_TYPE_PT_ADD80
8402 | OPTS_TYPE_PT_ADDBITS14
8403 | OPTS_TYPE_ST_ADD80;
8404 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8405 dgst_size = DGST_SIZE_4_4;
8406 parse_func = md5md5_parse_hash;
8407 sort_by_digest = sort_by_digest_4_4;
8408 opti_type = OPTI_TYPE_ZERO_BYTE
8409 | OPTI_TYPE_PRECOMPUTE_INIT
8410 | OPTI_TYPE_PRECOMPUTE_MERKLE
8411 | OPTI_TYPE_EARLY_SKIP;
8412 dgst_pos0 = 0;
8413 dgst_pos1 = 3;
8414 dgst_pos2 = 2;
8415 dgst_pos3 = 1;
8416 break;
8417
8418
8419 case 4400: hash_type = HASH_TYPE_MD5;
8420 salt_type = SALT_TYPE_NONE;
8421 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8422 opts_type = OPTS_TYPE_PT_GENERATE_BE
8423 | OPTS_TYPE_PT_ADD80
8424 | OPTS_TYPE_PT_ADDBITS15;
8425 kern_type = KERN_TYPE_MD5_SHA1;
8426 dgst_size = DGST_SIZE_4_4;
8427 parse_func = md5_parse_hash;
8428 sort_by_digest = sort_by_digest_4_4;
8429 opti_type = OPTI_TYPE_ZERO_BYTE
8430 | OPTI_TYPE_PRECOMPUTE_INIT
8431 | OPTI_TYPE_PRECOMPUTE_MERKLE
8432 | OPTI_TYPE_EARLY_SKIP
8433 | OPTI_TYPE_NOT_ITERATED
8434 | OPTI_TYPE_NOT_SALTED
8435 | OPTI_TYPE_RAW_HASH;
8436 dgst_pos0 = 0;
8437 dgst_pos1 = 3;
8438 dgst_pos2 = 2;
8439 dgst_pos3 = 1;
8440 break;
8441
8442 case 4500: hash_type = HASH_TYPE_SHA1;
8443 salt_type = SALT_TYPE_NONE;
8444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8445 opts_type = OPTS_TYPE_PT_GENERATE_BE
8446 | OPTS_TYPE_PT_ADD80
8447 | OPTS_TYPE_PT_ADDBITS15;
8448 kern_type = KERN_TYPE_SHA11;
8449 dgst_size = DGST_SIZE_4_5;
8450 parse_func = sha1_parse_hash;
8451 sort_by_digest = sort_by_digest_4_5;
8452 opti_type = OPTI_TYPE_ZERO_BYTE
8453 | OPTI_TYPE_PRECOMPUTE_INIT
8454 | OPTI_TYPE_PRECOMPUTE_MERKLE
8455 | OPTI_TYPE_EARLY_SKIP
8456 | OPTI_TYPE_NOT_SALTED;
8457 dgst_pos0 = 3;
8458 dgst_pos1 = 4;
8459 dgst_pos2 = 2;
8460 dgst_pos3 = 1;
8461 break;
8462
8463 case 4700: hash_type = HASH_TYPE_SHA1;
8464 salt_type = SALT_TYPE_NONE;
8465 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8466 opts_type = OPTS_TYPE_PT_GENERATE_LE
8467 | OPTS_TYPE_PT_ADD80
8468 | OPTS_TYPE_PT_ADDBITS14;
8469 kern_type = KERN_TYPE_SHA1_MD5;
8470 dgst_size = DGST_SIZE_4_5;
8471 parse_func = sha1_parse_hash;
8472 sort_by_digest = sort_by_digest_4_5;
8473 opti_type = OPTI_TYPE_ZERO_BYTE
8474 | OPTI_TYPE_PRECOMPUTE_INIT
8475 | OPTI_TYPE_PRECOMPUTE_MERKLE
8476 | OPTI_TYPE_EARLY_SKIP
8477 | OPTI_TYPE_NOT_ITERATED
8478 | OPTI_TYPE_NOT_SALTED
8479 | OPTI_TYPE_RAW_HASH;
8480 dgst_pos0 = 3;
8481 dgst_pos1 = 4;
8482 dgst_pos2 = 2;
8483 dgst_pos3 = 1;
8484 break;
8485
8486 case 4800: hash_type = HASH_TYPE_MD5;
8487 salt_type = SALT_TYPE_EMBEDDED;
8488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8489 opts_type = OPTS_TYPE_PT_GENERATE_LE
8490 | OPTS_TYPE_PT_ADDBITS14;
8491 kern_type = KERN_TYPE_MD5_CHAP;
8492 dgst_size = DGST_SIZE_4_4;
8493 parse_func = chap_parse_hash;
8494 sort_by_digest = sort_by_digest_4_4;
8495 opti_type = OPTI_TYPE_ZERO_BYTE
8496 | OPTI_TYPE_PRECOMPUTE_INIT
8497 | OPTI_TYPE_PRECOMPUTE_MERKLE
8498 | OPTI_TYPE_MEET_IN_MIDDLE
8499 | OPTI_TYPE_EARLY_SKIP
8500 | OPTI_TYPE_NOT_ITERATED
8501 | OPTI_TYPE_RAW_HASH;
8502 dgst_pos0 = 0;
8503 dgst_pos1 = 3;
8504 dgst_pos2 = 2;
8505 dgst_pos3 = 1;
8506 break;
8507
8508 case 4900: hash_type = HASH_TYPE_SHA1;
8509 salt_type = SALT_TYPE_INTERN;
8510 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8511 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8512 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8513 dgst_size = DGST_SIZE_4_5;
8514 parse_func = sha1s_parse_hash;
8515 sort_by_digest = sort_by_digest_4_5;
8516 opti_type = OPTI_TYPE_ZERO_BYTE
8517 | OPTI_TYPE_PRECOMPUTE_INIT
8518 | OPTI_TYPE_PRECOMPUTE_MERKLE
8519 | OPTI_TYPE_EARLY_SKIP;
8520 dgst_pos0 = 3;
8521 dgst_pos1 = 4;
8522 dgst_pos2 = 2;
8523 dgst_pos3 = 1;
8524 break;
8525
8526 case 5000: hash_type = HASH_TYPE_KECCAK;
8527 salt_type = SALT_TYPE_EMBEDDED;
8528 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8529 opts_type = OPTS_TYPE_PT_GENERATE_LE
8530 | OPTS_TYPE_PT_ADD01;
8531 kern_type = KERN_TYPE_KECCAK;
8532 dgst_size = DGST_SIZE_8_25;
8533 parse_func = keccak_parse_hash;
8534 sort_by_digest = sort_by_digest_8_25;
8535 opti_type = OPTI_TYPE_ZERO_BYTE
8536 | OPTI_TYPE_USES_BITS_64
8537 | OPTI_TYPE_RAW_HASH;
8538 dgst_pos0 = 2;
8539 dgst_pos1 = 3;
8540 dgst_pos2 = 4;
8541 dgst_pos3 = 5;
8542 break;
8543
8544 case 5100: hash_type = HASH_TYPE_MD5H;
8545 salt_type = SALT_TYPE_NONE;
8546 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8547 opts_type = OPTS_TYPE_PT_GENERATE_LE
8548 | OPTS_TYPE_PT_ADD80
8549 | OPTS_TYPE_PT_ADDBITS14;
8550 kern_type = KERN_TYPE_MD5H;
8551 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8552 parse_func = md5half_parse_hash;
8553 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8554 opti_type = OPTI_TYPE_ZERO_BYTE
8555 | OPTI_TYPE_RAW_HASH;
8556 dgst_pos0 = 0;
8557 dgst_pos1 = 1;
8558 dgst_pos2 = 2;
8559 dgst_pos3 = 3;
8560 break;
8561
8562 case 5200: hash_type = HASH_TYPE_SHA256;
8563 salt_type = SALT_TYPE_EMBEDDED;
8564 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8565 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8566 kern_type = KERN_TYPE_PSAFE3;
8567 dgst_size = DGST_SIZE_4_8;
8568 parse_func = psafe3_parse_hash;
8569 sort_by_digest = sort_by_digest_4_8;
8570 opti_type = OPTI_TYPE_ZERO_BYTE;
8571 dgst_pos0 = 0;
8572 dgst_pos1 = 1;
8573 dgst_pos2 = 2;
8574 dgst_pos3 = 3;
8575 break;
8576
8577 case 5300: hash_type = HASH_TYPE_MD5;
8578 salt_type = SALT_TYPE_EMBEDDED;
8579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8580 opts_type = OPTS_TYPE_PT_GENERATE_LE
8581 | OPTS_TYPE_ST_ADD80;
8582 kern_type = KERN_TYPE_IKEPSK_MD5;
8583 dgst_size = DGST_SIZE_4_4;
8584 parse_func = ikepsk_md5_parse_hash;
8585 sort_by_digest = sort_by_digest_4_4;
8586 opti_type = OPTI_TYPE_ZERO_BYTE;
8587 dgst_pos0 = 0;
8588 dgst_pos1 = 3;
8589 dgst_pos2 = 2;
8590 dgst_pos3 = 1;
8591 break;
8592
8593 case 5400: hash_type = HASH_TYPE_SHA1;
8594 salt_type = SALT_TYPE_EMBEDDED;
8595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8596 opts_type = OPTS_TYPE_PT_GENERATE_BE
8597 | OPTS_TYPE_ST_ADD80;
8598 kern_type = KERN_TYPE_IKEPSK_SHA1;
8599 dgst_size = DGST_SIZE_4_5;
8600 parse_func = ikepsk_sha1_parse_hash;
8601 sort_by_digest = sort_by_digest_4_5;
8602 opti_type = OPTI_TYPE_ZERO_BYTE;
8603 dgst_pos0 = 3;
8604 dgst_pos1 = 4;
8605 dgst_pos2 = 2;
8606 dgst_pos3 = 1;
8607 break;
8608
8609 case 5500: hash_type = HASH_TYPE_NETNTLM;
8610 salt_type = SALT_TYPE_EMBEDDED;
8611 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8612 opts_type = OPTS_TYPE_PT_GENERATE_LE
8613 | OPTS_TYPE_PT_ADD80
8614 | OPTS_TYPE_PT_ADDBITS14
8615 | OPTS_TYPE_PT_UNICODE
8616 | OPTS_TYPE_ST_HEX;
8617 kern_type = KERN_TYPE_NETNTLMv1;
8618 dgst_size = DGST_SIZE_4_4;
8619 parse_func = netntlmv1_parse_hash;
8620 sort_by_digest = sort_by_digest_4_4;
8621 opti_type = OPTI_TYPE_ZERO_BYTE
8622 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8623 dgst_pos0 = 0;
8624 dgst_pos1 = 1;
8625 dgst_pos2 = 2;
8626 dgst_pos3 = 3;
8627 break;
8628
8629 case 5600: hash_type = HASH_TYPE_MD5;
8630 salt_type = SALT_TYPE_EMBEDDED;
8631 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8632 opts_type = OPTS_TYPE_PT_GENERATE_LE
8633 | OPTS_TYPE_PT_ADD80
8634 | OPTS_TYPE_PT_ADDBITS14
8635 | OPTS_TYPE_PT_UNICODE;
8636 kern_type = KERN_TYPE_NETNTLMv2;
8637 dgst_size = DGST_SIZE_4_4;
8638 parse_func = netntlmv2_parse_hash;
8639 sort_by_digest = sort_by_digest_4_4;
8640 opti_type = OPTI_TYPE_ZERO_BYTE;
8641 dgst_pos0 = 0;
8642 dgst_pos1 = 3;
8643 dgst_pos2 = 2;
8644 dgst_pos3 = 1;
8645 break;
8646
8647 case 5700: hash_type = HASH_TYPE_SHA256;
8648 salt_type = SALT_TYPE_NONE;
8649 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8650 opts_type = OPTS_TYPE_PT_GENERATE_BE
8651 | OPTS_TYPE_PT_ADD80
8652 | OPTS_TYPE_PT_ADDBITS15;
8653 kern_type = KERN_TYPE_SHA256;
8654 dgst_size = DGST_SIZE_4_8;
8655 parse_func = cisco4_parse_hash;
8656 sort_by_digest = sort_by_digest_4_8;
8657 opti_type = OPTI_TYPE_ZERO_BYTE
8658 | OPTI_TYPE_PRECOMPUTE_INIT
8659 | OPTI_TYPE_PRECOMPUTE_MERKLE
8660 | OPTI_TYPE_EARLY_SKIP
8661 | OPTI_TYPE_NOT_ITERATED
8662 | OPTI_TYPE_NOT_SALTED
8663 | OPTI_TYPE_RAW_HASH;
8664 dgst_pos0 = 3;
8665 dgst_pos1 = 7;
8666 dgst_pos2 = 2;
8667 dgst_pos3 = 6;
8668 break;
8669
8670 case 5800: hash_type = HASH_TYPE_SHA1;
8671 salt_type = SALT_TYPE_INTERN;
8672 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8673 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8674 | OPTS_TYPE_ST_ADD80;
8675 kern_type = KERN_TYPE_ANDROIDPIN;
8676 dgst_size = DGST_SIZE_4_5;
8677 parse_func = androidpin_parse_hash;
8678 sort_by_digest = sort_by_digest_4_5;
8679 opti_type = OPTI_TYPE_ZERO_BYTE;
8680 dgst_pos0 = 0;
8681 dgst_pos1 = 1;
8682 dgst_pos2 = 2;
8683 dgst_pos3 = 3;
8684 break;
8685
8686 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8687 salt_type = SALT_TYPE_NONE;
8688 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8689 opts_type = OPTS_TYPE_PT_GENERATE_LE
8690 | OPTS_TYPE_PT_ADD80;
8691 kern_type = KERN_TYPE_RIPEMD160;
8692 dgst_size = DGST_SIZE_4_5;
8693 parse_func = ripemd160_parse_hash;
8694 sort_by_digest = sort_by_digest_4_5;
8695 opti_type = OPTI_TYPE_ZERO_BYTE;
8696 dgst_pos0 = 0;
8697 dgst_pos1 = 1;
8698 dgst_pos2 = 2;
8699 dgst_pos3 = 3;
8700 break;
8701
8702 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8703 salt_type = SALT_TYPE_NONE;
8704 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8705 opts_type = OPTS_TYPE_PT_GENERATE_BE
8706 | OPTS_TYPE_PT_ADD80;
8707 kern_type = KERN_TYPE_WHIRLPOOL;
8708 dgst_size = DGST_SIZE_4_16;
8709 parse_func = whirlpool_parse_hash;
8710 sort_by_digest = sort_by_digest_4_16;
8711 opti_type = OPTI_TYPE_ZERO_BYTE;
8712 dgst_pos0 = 0;
8713 dgst_pos1 = 1;
8714 dgst_pos2 = 2;
8715 dgst_pos3 = 3;
8716 break;
8717
8718 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8719 salt_type = SALT_TYPE_EMBEDDED;
8720 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8721 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8722 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8723 dgst_size = DGST_SIZE_4_5;
8724 parse_func = truecrypt_parse_hash_2k;
8725 sort_by_digest = sort_by_digest_4_5;
8726 opti_type = OPTI_TYPE_ZERO_BYTE;
8727 dgst_pos0 = 0;
8728 dgst_pos1 = 1;
8729 dgst_pos2 = 2;
8730 dgst_pos3 = 3;
8731 break;
8732
8733 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8734 salt_type = SALT_TYPE_EMBEDDED;
8735 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8736 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8737 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8738 dgst_size = DGST_SIZE_4_5;
8739 parse_func = truecrypt_parse_hash_2k;
8740 sort_by_digest = sort_by_digest_4_5;
8741 opti_type = OPTI_TYPE_ZERO_BYTE;
8742 dgst_pos0 = 0;
8743 dgst_pos1 = 1;
8744 dgst_pos2 = 2;
8745 dgst_pos3 = 3;
8746 break;
8747
8748 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8749 salt_type = SALT_TYPE_EMBEDDED;
8750 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8751 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8752 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8753 dgst_size = DGST_SIZE_4_5;
8754 parse_func = truecrypt_parse_hash_2k;
8755 sort_by_digest = sort_by_digest_4_5;
8756 opti_type = OPTI_TYPE_ZERO_BYTE;
8757 dgst_pos0 = 0;
8758 dgst_pos1 = 1;
8759 dgst_pos2 = 2;
8760 dgst_pos3 = 3;
8761 break;
8762
8763 case 6221: hash_type = HASH_TYPE_SHA512;
8764 salt_type = SALT_TYPE_EMBEDDED;
8765 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8766 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8767 kern_type = KERN_TYPE_TCSHA512_XTS512;
8768 dgst_size = DGST_SIZE_8_8;
8769 parse_func = truecrypt_parse_hash_1k;
8770 sort_by_digest = sort_by_digest_8_8;
8771 opti_type = OPTI_TYPE_ZERO_BYTE
8772 | OPTI_TYPE_USES_BITS_64;
8773 dgst_pos0 = 0;
8774 dgst_pos1 = 1;
8775 dgst_pos2 = 2;
8776 dgst_pos3 = 3;
8777 break;
8778
8779 case 6222: hash_type = HASH_TYPE_SHA512;
8780 salt_type = SALT_TYPE_EMBEDDED;
8781 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8782 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8783 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8784 dgst_size = DGST_SIZE_8_8;
8785 parse_func = truecrypt_parse_hash_1k;
8786 sort_by_digest = sort_by_digest_8_8;
8787 opti_type = OPTI_TYPE_ZERO_BYTE
8788 | OPTI_TYPE_USES_BITS_64;
8789 dgst_pos0 = 0;
8790 dgst_pos1 = 1;
8791 dgst_pos2 = 2;
8792 dgst_pos3 = 3;
8793 break;
8794
8795 case 6223: hash_type = HASH_TYPE_SHA512;
8796 salt_type = SALT_TYPE_EMBEDDED;
8797 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8798 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8799 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8800 dgst_size = DGST_SIZE_8_8;
8801 parse_func = truecrypt_parse_hash_1k;
8802 sort_by_digest = sort_by_digest_8_8;
8803 opti_type = OPTI_TYPE_ZERO_BYTE
8804 | OPTI_TYPE_USES_BITS_64;
8805 dgst_pos0 = 0;
8806 dgst_pos1 = 1;
8807 dgst_pos2 = 2;
8808 dgst_pos3 = 3;
8809 break;
8810
8811 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8812 salt_type = SALT_TYPE_EMBEDDED;
8813 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8814 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8815 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8816 dgst_size = DGST_SIZE_4_8;
8817 parse_func = truecrypt_parse_hash_1k;
8818 sort_by_digest = sort_by_digest_4_8;
8819 opti_type = OPTI_TYPE_ZERO_BYTE;
8820 dgst_pos0 = 0;
8821 dgst_pos1 = 1;
8822 dgst_pos2 = 2;
8823 dgst_pos3 = 3;
8824 break;
8825
8826 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8827 salt_type = SALT_TYPE_EMBEDDED;
8828 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8829 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8830 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8831 dgst_size = DGST_SIZE_4_8;
8832 parse_func = truecrypt_parse_hash_1k;
8833 sort_by_digest = sort_by_digest_4_8;
8834 opti_type = OPTI_TYPE_ZERO_BYTE;
8835 dgst_pos0 = 0;
8836 dgst_pos1 = 1;
8837 dgst_pos2 = 2;
8838 dgst_pos3 = 3;
8839 break;
8840
8841 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8842 salt_type = SALT_TYPE_EMBEDDED;
8843 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8844 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8845 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8846 dgst_size = DGST_SIZE_4_8;
8847 parse_func = truecrypt_parse_hash_1k;
8848 sort_by_digest = sort_by_digest_4_8;
8849 opti_type = OPTI_TYPE_ZERO_BYTE;
8850 dgst_pos0 = 0;
8851 dgst_pos1 = 1;
8852 dgst_pos2 = 2;
8853 dgst_pos3 = 3;
8854 break;
8855
8856 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8857 salt_type = SALT_TYPE_EMBEDDED;
8858 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8859 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8860 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8861 dgst_size = DGST_SIZE_4_5;
8862 parse_func = truecrypt_parse_hash_1k;
8863 sort_by_digest = sort_by_digest_4_5;
8864 opti_type = OPTI_TYPE_ZERO_BYTE;
8865 dgst_pos0 = 0;
8866 dgst_pos1 = 1;
8867 dgst_pos2 = 2;
8868 dgst_pos3 = 3;
8869 break;
8870
8871 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8872 salt_type = SALT_TYPE_EMBEDDED;
8873 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8874 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8875 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8876 dgst_size = DGST_SIZE_4_5;
8877 parse_func = truecrypt_parse_hash_1k;
8878 sort_by_digest = sort_by_digest_4_5;
8879 opti_type = OPTI_TYPE_ZERO_BYTE;
8880 dgst_pos0 = 0;
8881 dgst_pos1 = 1;
8882 dgst_pos2 = 2;
8883 dgst_pos3 = 3;
8884 break;
8885
8886 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8887 salt_type = SALT_TYPE_EMBEDDED;
8888 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8889 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8890 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8891 dgst_size = DGST_SIZE_4_5;
8892 parse_func = truecrypt_parse_hash_1k;
8893 sort_by_digest = sort_by_digest_4_5;
8894 opti_type = OPTI_TYPE_ZERO_BYTE;
8895 dgst_pos0 = 0;
8896 dgst_pos1 = 1;
8897 dgst_pos2 = 2;
8898 dgst_pos3 = 3;
8899 break;
8900
8901 case 6300: hash_type = HASH_TYPE_MD5;
8902 salt_type = SALT_TYPE_EMBEDDED;
8903 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8904 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8905 kern_type = KERN_TYPE_MD5AIX;
8906 dgst_size = DGST_SIZE_4_4;
8907 parse_func = md5aix_parse_hash;
8908 sort_by_digest = sort_by_digest_4_4;
8909 opti_type = OPTI_TYPE_ZERO_BYTE;
8910 dgst_pos0 = 0;
8911 dgst_pos1 = 1;
8912 dgst_pos2 = 2;
8913 dgst_pos3 = 3;
8914 break;
8915
8916 case 6400: hash_type = HASH_TYPE_SHA256;
8917 salt_type = SALT_TYPE_EMBEDDED;
8918 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8919 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8920 kern_type = KERN_TYPE_SHA256AIX;
8921 dgst_size = DGST_SIZE_4_8;
8922 parse_func = sha256aix_parse_hash;
8923 sort_by_digest = sort_by_digest_4_8;
8924 opti_type = OPTI_TYPE_ZERO_BYTE;
8925 dgst_pos0 = 0;
8926 dgst_pos1 = 1;
8927 dgst_pos2 = 2;
8928 dgst_pos3 = 3;
8929 break;
8930
8931 case 6500: hash_type = HASH_TYPE_SHA512;
8932 salt_type = SALT_TYPE_EMBEDDED;
8933 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8934 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8935 kern_type = KERN_TYPE_SHA512AIX;
8936 dgst_size = DGST_SIZE_8_8;
8937 parse_func = sha512aix_parse_hash;
8938 sort_by_digest = sort_by_digest_8_8;
8939 opti_type = OPTI_TYPE_ZERO_BYTE
8940 | OPTI_TYPE_USES_BITS_64;
8941 dgst_pos0 = 0;
8942 dgst_pos1 = 1;
8943 dgst_pos2 = 2;
8944 dgst_pos3 = 3;
8945 break;
8946
8947 case 6600: hash_type = HASH_TYPE_AES;
8948 salt_type = SALT_TYPE_EMBEDDED;
8949 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8950 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8951 kern_type = KERN_TYPE_AGILEKEY;
8952 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8953 parse_func = agilekey_parse_hash;
8954 sort_by_digest = sort_by_digest_4_5;
8955 opti_type = OPTI_TYPE_ZERO_BYTE;
8956 dgst_pos0 = 0;
8957 dgst_pos1 = 1;
8958 dgst_pos2 = 2;
8959 dgst_pos3 = 3;
8960 break;
8961
8962 case 6700: hash_type = HASH_TYPE_SHA1;
8963 salt_type = SALT_TYPE_EMBEDDED;
8964 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8965 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8966 kern_type = KERN_TYPE_SHA1AIX;
8967 dgst_size = DGST_SIZE_4_5;
8968 parse_func = sha1aix_parse_hash;
8969 sort_by_digest = sort_by_digest_4_5;
8970 opti_type = OPTI_TYPE_ZERO_BYTE;
8971 dgst_pos0 = 0;
8972 dgst_pos1 = 1;
8973 dgst_pos2 = 2;
8974 dgst_pos3 = 3;
8975 break;
8976
8977 case 6800: hash_type = HASH_TYPE_AES;
8978 salt_type = SALT_TYPE_EMBEDDED;
8979 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8980 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8981 kern_type = KERN_TYPE_LASTPASS;
8982 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8983 parse_func = lastpass_parse_hash;
8984 sort_by_digest = sort_by_digest_4_8;
8985 opti_type = OPTI_TYPE_ZERO_BYTE;
8986 dgst_pos0 = 0;
8987 dgst_pos1 = 1;
8988 dgst_pos2 = 2;
8989 dgst_pos3 = 3;
8990 break;
8991
8992 case 6900: hash_type = HASH_TYPE_GOST;
8993 salt_type = SALT_TYPE_NONE;
8994 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8995 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8996 kern_type = KERN_TYPE_GOST;
8997 dgst_size = DGST_SIZE_4_8;
8998 parse_func = gost_parse_hash;
8999 sort_by_digest = sort_by_digest_4_8;
9000 opti_type = OPTI_TYPE_ZERO_BYTE;
9001 dgst_pos0 = 0;
9002 dgst_pos1 = 1;
9003 dgst_pos2 = 2;
9004 dgst_pos3 = 3;
9005 break;
9006
9007 case 7100: hash_type = HASH_TYPE_SHA512;
9008 salt_type = SALT_TYPE_EMBEDDED;
9009 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9010 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9011 kern_type = KERN_TYPE_PBKDF2_SHA512;
9012 dgst_size = DGST_SIZE_8_16;
9013 parse_func = sha512osx_parse_hash;
9014 sort_by_digest = sort_by_digest_8_16;
9015 opti_type = OPTI_TYPE_ZERO_BYTE
9016 | OPTI_TYPE_USES_BITS_64;
9017 dgst_pos0 = 0;
9018 dgst_pos1 = 1;
9019 dgst_pos2 = 2;
9020 dgst_pos3 = 3;
9021 break;
9022
9023 case 7200: hash_type = HASH_TYPE_SHA512;
9024 salt_type = SALT_TYPE_EMBEDDED;
9025 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9026 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9027 kern_type = KERN_TYPE_PBKDF2_SHA512;
9028 dgst_size = DGST_SIZE_8_16;
9029 parse_func = sha512grub_parse_hash;
9030 sort_by_digest = sort_by_digest_8_16;
9031 opti_type = OPTI_TYPE_ZERO_BYTE
9032 | OPTI_TYPE_USES_BITS_64;
9033 dgst_pos0 = 0;
9034 dgst_pos1 = 1;
9035 dgst_pos2 = 2;
9036 dgst_pos3 = 3;
9037 break;
9038
9039 case 7300: hash_type = HASH_TYPE_SHA1;
9040 salt_type = SALT_TYPE_EMBEDDED;
9041 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9042 opts_type = OPTS_TYPE_PT_GENERATE_BE
9043 | OPTS_TYPE_ST_ADD80
9044 | OPTS_TYPE_ST_ADDBITS15;
9045 kern_type = KERN_TYPE_RAKP;
9046 dgst_size = DGST_SIZE_4_5;
9047 parse_func = rakp_parse_hash;
9048 sort_by_digest = sort_by_digest_4_5;
9049 opti_type = OPTI_TYPE_ZERO_BYTE
9050 | OPTI_TYPE_NOT_ITERATED;
9051 dgst_pos0 = 3;
9052 dgst_pos1 = 4;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 1;
9055 break;
9056
9057 case 7400: hash_type = HASH_TYPE_SHA256;
9058 salt_type = SALT_TYPE_EMBEDDED;
9059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9060 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9061 kern_type = KERN_TYPE_SHA256CRYPT;
9062 dgst_size = DGST_SIZE_4_8;
9063 parse_func = sha256crypt_parse_hash;
9064 sort_by_digest = sort_by_digest_4_8;
9065 opti_type = OPTI_TYPE_ZERO_BYTE;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 1;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 3;
9070 break;
9071
9072 case 7500: hash_type = HASH_TYPE_KRB5PA;
9073 salt_type = SALT_TYPE_EMBEDDED;
9074 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9075 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9076 kern_type = KERN_TYPE_KRB5PA;
9077 dgst_size = DGST_SIZE_4_4;
9078 parse_func = krb5pa_parse_hash;
9079 sort_by_digest = sort_by_digest_4_4;
9080 opti_type = OPTI_TYPE_ZERO_BYTE
9081 | OPTI_TYPE_NOT_ITERATED;
9082 dgst_pos0 = 0;
9083 dgst_pos1 = 1;
9084 dgst_pos2 = 2;
9085 dgst_pos3 = 3;
9086 break;
9087
9088 case 7600: hash_type = HASH_TYPE_SHA1;
9089 salt_type = SALT_TYPE_INTERN;
9090 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9091 opts_type = OPTS_TYPE_PT_GENERATE_BE
9092 | OPTS_TYPE_PT_ADD80
9093 | OPTS_TYPE_PT_ADDBITS15;
9094 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9095 dgst_size = DGST_SIZE_4_5;
9096 parse_func = redmine_parse_hash;
9097 sort_by_digest = sort_by_digest_4_5;
9098 opti_type = OPTI_TYPE_ZERO_BYTE
9099 | OPTI_TYPE_PRECOMPUTE_INIT
9100 | OPTI_TYPE_EARLY_SKIP
9101 | OPTI_TYPE_NOT_ITERATED
9102 | OPTI_TYPE_PREPENDED_SALT;
9103 dgst_pos0 = 3;
9104 dgst_pos1 = 4;
9105 dgst_pos2 = 2;
9106 dgst_pos3 = 1;
9107 break;
9108
9109 case 7700: hash_type = HASH_TYPE_SAPB;
9110 salt_type = SALT_TYPE_EMBEDDED;
9111 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9112 opts_type = OPTS_TYPE_PT_GENERATE_LE
9113 | OPTS_TYPE_PT_UPPER
9114 | OPTS_TYPE_ST_UPPER;
9115 kern_type = KERN_TYPE_SAPB;
9116 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9117 parse_func = sapb_parse_hash;
9118 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9119 opti_type = OPTI_TYPE_ZERO_BYTE
9120 | OPTI_TYPE_PRECOMPUTE_INIT
9121 | OPTI_TYPE_NOT_ITERATED;
9122 dgst_pos0 = 0;
9123 dgst_pos1 = 1;
9124 dgst_pos2 = 2;
9125 dgst_pos3 = 3;
9126 break;
9127
9128 case 7800: hash_type = HASH_TYPE_SAPG;
9129 salt_type = SALT_TYPE_EMBEDDED;
9130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9131 opts_type = OPTS_TYPE_PT_GENERATE_BE
9132 | OPTS_TYPE_ST_ADD80
9133 | OPTS_TYPE_ST_UPPER;
9134 kern_type = KERN_TYPE_SAPG;
9135 dgst_size = DGST_SIZE_4_5;
9136 parse_func = sapg_parse_hash;
9137 sort_by_digest = sort_by_digest_4_5;
9138 opti_type = OPTI_TYPE_ZERO_BYTE
9139 | OPTI_TYPE_PRECOMPUTE_INIT
9140 | OPTI_TYPE_NOT_ITERATED;
9141 dgst_pos0 = 3;
9142 dgst_pos1 = 4;
9143 dgst_pos2 = 2;
9144 dgst_pos3 = 1;
9145 break;
9146
9147 case 7900: hash_type = HASH_TYPE_SHA512;
9148 salt_type = SALT_TYPE_EMBEDDED;
9149 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9150 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9151 kern_type = KERN_TYPE_DRUPAL7;
9152 dgst_size = DGST_SIZE_8_8;
9153 parse_func = drupal7_parse_hash;
9154 sort_by_digest = sort_by_digest_8_8;
9155 opti_type = OPTI_TYPE_ZERO_BYTE
9156 | OPTI_TYPE_USES_BITS_64;
9157 dgst_pos0 = 0;
9158 dgst_pos1 = 1;
9159 dgst_pos2 = 2;
9160 dgst_pos3 = 3;
9161 break;
9162
9163 case 8000: hash_type = HASH_TYPE_SHA256;
9164 salt_type = SALT_TYPE_EMBEDDED;
9165 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9166 opts_type = OPTS_TYPE_PT_GENERATE_BE
9167 | OPTS_TYPE_PT_UNICODE
9168 | OPTS_TYPE_ST_ADD80
9169 | OPTS_TYPE_ST_HEX;
9170 kern_type = KERN_TYPE_SYBASEASE;
9171 dgst_size = DGST_SIZE_4_8;
9172 parse_func = sybasease_parse_hash;
9173 sort_by_digest = sort_by_digest_4_8;
9174 opti_type = OPTI_TYPE_ZERO_BYTE
9175 | OPTI_TYPE_PRECOMPUTE_INIT
9176 | OPTI_TYPE_EARLY_SKIP
9177 | OPTI_TYPE_NOT_ITERATED
9178 | OPTI_TYPE_RAW_HASH;
9179 dgst_pos0 = 3;
9180 dgst_pos1 = 7;
9181 dgst_pos2 = 2;
9182 dgst_pos3 = 6;
9183 break;
9184
9185 case 8100: hash_type = HASH_TYPE_SHA1;
9186 salt_type = SALT_TYPE_EMBEDDED;
9187 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9188 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9189 kern_type = KERN_TYPE_NETSCALER;
9190 dgst_size = DGST_SIZE_4_5;
9191 parse_func = netscaler_parse_hash;
9192 sort_by_digest = sort_by_digest_4_5;
9193 opti_type = OPTI_TYPE_ZERO_BYTE
9194 | OPTI_TYPE_PRECOMPUTE_INIT
9195 | OPTI_TYPE_PRECOMPUTE_MERKLE
9196 | OPTI_TYPE_EARLY_SKIP
9197 | OPTI_TYPE_NOT_ITERATED
9198 | OPTI_TYPE_PREPENDED_SALT
9199 | OPTI_TYPE_RAW_HASH;
9200 dgst_pos0 = 3;
9201 dgst_pos1 = 4;
9202 dgst_pos2 = 2;
9203 dgst_pos3 = 1;
9204 break;
9205
9206 case 8200: hash_type = HASH_TYPE_SHA256;
9207 salt_type = SALT_TYPE_EMBEDDED;
9208 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9209 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9210 kern_type = KERN_TYPE_CLOUDKEY;
9211 dgst_size = DGST_SIZE_4_8;
9212 parse_func = cloudkey_parse_hash;
9213 sort_by_digest = sort_by_digest_4_8;
9214 opti_type = OPTI_TYPE_ZERO_BYTE;
9215 dgst_pos0 = 0;
9216 dgst_pos1 = 1;
9217 dgst_pos2 = 2;
9218 dgst_pos3 = 3;
9219 break;
9220
9221 case 8300: hash_type = HASH_TYPE_SHA1;
9222 salt_type = SALT_TYPE_EMBEDDED;
9223 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9224 opts_type = OPTS_TYPE_PT_GENERATE_BE
9225 | OPTS_TYPE_ST_HEX
9226 | OPTS_TYPE_ST_ADD80;
9227 kern_type = KERN_TYPE_NSEC3;
9228 dgst_size = DGST_SIZE_4_5;
9229 parse_func = nsec3_parse_hash;
9230 sort_by_digest = sort_by_digest_4_5;
9231 opti_type = OPTI_TYPE_ZERO_BYTE;
9232 dgst_pos0 = 3;
9233 dgst_pos1 = 4;
9234 dgst_pos2 = 2;
9235 dgst_pos3 = 1;
9236 break;
9237
9238 case 8400: hash_type = HASH_TYPE_SHA1;
9239 salt_type = SALT_TYPE_INTERN;
9240 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9241 opts_type = OPTS_TYPE_PT_GENERATE_BE
9242 | OPTS_TYPE_PT_ADD80
9243 | OPTS_TYPE_PT_ADDBITS15;
9244 kern_type = KERN_TYPE_WBB3;
9245 dgst_size = DGST_SIZE_4_5;
9246 parse_func = wbb3_parse_hash;
9247 sort_by_digest = sort_by_digest_4_5;
9248 opti_type = OPTI_TYPE_ZERO_BYTE
9249 | OPTI_TYPE_PRECOMPUTE_INIT
9250 | OPTI_TYPE_NOT_ITERATED;
9251 dgst_pos0 = 3;
9252 dgst_pos1 = 4;
9253 dgst_pos2 = 2;
9254 dgst_pos3 = 1;
9255 break;
9256
9257 case 8500: hash_type = HASH_TYPE_DESRACF;
9258 salt_type = SALT_TYPE_EMBEDDED;
9259 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9260 opts_type = OPTS_TYPE_PT_GENERATE_LE
9261 | OPTS_TYPE_ST_UPPER;
9262 kern_type = KERN_TYPE_RACF;
9263 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9264 parse_func = racf_parse_hash;
9265 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9266 opti_type = OPTI_TYPE_ZERO_BYTE
9267 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9268 dgst_pos0 = 0;
9269 dgst_pos1 = 1;
9270 dgst_pos2 = 2;
9271 dgst_pos3 = 3;
9272 break;
9273
9274 case 8600: hash_type = HASH_TYPE_LOTUS5;
9275 salt_type = SALT_TYPE_NONE;
9276 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9277 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9278 kern_type = KERN_TYPE_LOTUS5;
9279 dgst_size = DGST_SIZE_4_4;
9280 parse_func = lotus5_parse_hash;
9281 sort_by_digest = sort_by_digest_4_4;
9282 opti_type = OPTI_TYPE_EARLY_SKIP
9283 | OPTI_TYPE_NOT_ITERATED
9284 | OPTI_TYPE_NOT_SALTED
9285 | OPTI_TYPE_RAW_HASH;
9286 dgst_pos0 = 0;
9287 dgst_pos1 = 1;
9288 dgst_pos2 = 2;
9289 dgst_pos3 = 3;
9290 break;
9291
9292 case 8700: hash_type = HASH_TYPE_LOTUS6;
9293 salt_type = SALT_TYPE_EMBEDDED;
9294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9295 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9296 kern_type = KERN_TYPE_LOTUS6;
9297 dgst_size = DGST_SIZE_4_4;
9298 parse_func = lotus6_parse_hash;
9299 sort_by_digest = sort_by_digest_4_4;
9300 opti_type = OPTI_TYPE_EARLY_SKIP
9301 | OPTI_TYPE_NOT_ITERATED
9302 | OPTI_TYPE_RAW_HASH;
9303 dgst_pos0 = 0;
9304 dgst_pos1 = 1;
9305 dgst_pos2 = 2;
9306 dgst_pos3 = 3;
9307 break;
9308
9309 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9310 salt_type = SALT_TYPE_EMBEDDED;
9311 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9312 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9313 kern_type = KERN_TYPE_ANDROIDFDE;
9314 dgst_size = DGST_SIZE_4_4;
9315 parse_func = androidfde_parse_hash;
9316 sort_by_digest = sort_by_digest_4_4;
9317 opti_type = OPTI_TYPE_ZERO_BYTE;
9318 dgst_pos0 = 0;
9319 dgst_pos1 = 1;
9320 dgst_pos2 = 2;
9321 dgst_pos3 = 3;
9322 break;
9323
9324 case 8900: hash_type = HASH_TYPE_SCRYPT;
9325 salt_type = SALT_TYPE_EMBEDDED;
9326 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9327 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9328 kern_type = KERN_TYPE_SCRYPT;
9329 dgst_size = DGST_SIZE_4_8;
9330 parse_func = scrypt_parse_hash;
9331 sort_by_digest = sort_by_digest_4_8;
9332 opti_type = OPTI_TYPE_ZERO_BYTE;
9333 dgst_pos0 = 0;
9334 dgst_pos1 = 1;
9335 dgst_pos2 = 2;
9336 dgst_pos3 = 3;
9337 break;
9338
9339 case 9000: hash_type = HASH_TYPE_SHA1;
9340 salt_type = SALT_TYPE_EMBEDDED;
9341 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9342 opts_type = OPTS_TYPE_PT_GENERATE_LE
9343 | OPTS_TYPE_ST_GENERATE_LE;
9344 kern_type = KERN_TYPE_PSAFE2;
9345 dgst_size = DGST_SIZE_4_5;
9346 parse_func = psafe2_parse_hash;
9347 sort_by_digest = sort_by_digest_4_5;
9348 opti_type = OPTI_TYPE_ZERO_BYTE;
9349 dgst_pos0 = 0;
9350 dgst_pos1 = 1;
9351 dgst_pos2 = 2;
9352 dgst_pos3 = 3;
9353 break;
9354
9355 case 9100: hash_type = HASH_TYPE_LOTUS8;
9356 salt_type = SALT_TYPE_EMBEDDED;
9357 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9358 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9359 kern_type = KERN_TYPE_LOTUS8;
9360 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9361 parse_func = lotus8_parse_hash;
9362 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9363 opti_type = OPTI_TYPE_ZERO_BYTE;
9364 dgst_pos0 = 0;
9365 dgst_pos1 = 1;
9366 dgst_pos2 = 2;
9367 dgst_pos3 = 3;
9368 break;
9369
9370 case 9200: hash_type = HASH_TYPE_SHA256;
9371 salt_type = SALT_TYPE_EMBEDDED;
9372 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9373 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9374 kern_type = KERN_TYPE_PBKDF2_SHA256;
9375 dgst_size = DGST_SIZE_4_32;
9376 parse_func = cisco8_parse_hash;
9377 sort_by_digest = sort_by_digest_4_32;
9378 opti_type = OPTI_TYPE_ZERO_BYTE;
9379 dgst_pos0 = 0;
9380 dgst_pos1 = 1;
9381 dgst_pos2 = 2;
9382 dgst_pos3 = 3;
9383 break;
9384
9385 case 9300: hash_type = HASH_TYPE_SCRYPT;
9386 salt_type = SALT_TYPE_EMBEDDED;
9387 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9388 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9389 kern_type = KERN_TYPE_SCRYPT;
9390 dgst_size = DGST_SIZE_4_8;
9391 parse_func = cisco9_parse_hash;
9392 sort_by_digest = sort_by_digest_4_8;
9393 opti_type = OPTI_TYPE_ZERO_BYTE;
9394 dgst_pos0 = 0;
9395 dgst_pos1 = 1;
9396 dgst_pos2 = 2;
9397 dgst_pos3 = 3;
9398 break;
9399
9400 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9401 salt_type = SALT_TYPE_EMBEDDED;
9402 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9403 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9404 kern_type = KERN_TYPE_OFFICE2007;
9405 dgst_size = DGST_SIZE_4_4;
9406 parse_func = office2007_parse_hash;
9407 sort_by_digest = sort_by_digest_4_4;
9408 opti_type = OPTI_TYPE_ZERO_BYTE;
9409 dgst_pos0 = 0;
9410 dgst_pos1 = 1;
9411 dgst_pos2 = 2;
9412 dgst_pos3 = 3;
9413 break;
9414
9415 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9416 salt_type = SALT_TYPE_EMBEDDED;
9417 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9418 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9419 kern_type = KERN_TYPE_OFFICE2010;
9420 dgst_size = DGST_SIZE_4_4;
9421 parse_func = office2010_parse_hash;
9422 sort_by_digest = sort_by_digest_4_4;
9423 opti_type = OPTI_TYPE_ZERO_BYTE;
9424 dgst_pos0 = 0;
9425 dgst_pos1 = 1;
9426 dgst_pos2 = 2;
9427 dgst_pos3 = 3;
9428 break;
9429
9430 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9431 salt_type = SALT_TYPE_EMBEDDED;
9432 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9433 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9434 kern_type = KERN_TYPE_OFFICE2013;
9435 dgst_size = DGST_SIZE_4_4;
9436 parse_func = office2013_parse_hash;
9437 sort_by_digest = sort_by_digest_4_4;
9438 opti_type = OPTI_TYPE_ZERO_BYTE;
9439 dgst_pos0 = 0;
9440 dgst_pos1 = 1;
9441 dgst_pos2 = 2;
9442 dgst_pos3 = 3;
9443 break;
9444
9445 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9446 salt_type = SALT_TYPE_EMBEDDED;
9447 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9448 opts_type = OPTS_TYPE_PT_GENERATE_LE
9449 | OPTS_TYPE_PT_ADD80
9450 | OPTS_TYPE_PT_UNICODE;
9451 kern_type = KERN_TYPE_OLDOFFICE01;
9452 dgst_size = DGST_SIZE_4_4;
9453 parse_func = oldoffice01_parse_hash;
9454 sort_by_digest = sort_by_digest_4_4;
9455 opti_type = OPTI_TYPE_ZERO_BYTE
9456 | OPTI_TYPE_PRECOMPUTE_INIT
9457 | OPTI_TYPE_NOT_ITERATED;
9458 dgst_pos0 = 0;
9459 dgst_pos1 = 1;
9460 dgst_pos2 = 2;
9461 dgst_pos3 = 3;
9462 break;
9463
9464 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9465 salt_type = SALT_TYPE_EMBEDDED;
9466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9467 opts_type = OPTS_TYPE_PT_GENERATE_LE
9468 | OPTS_TYPE_PT_ADD80;
9469 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9470 dgst_size = DGST_SIZE_4_4;
9471 parse_func = oldoffice01cm1_parse_hash;
9472 sort_by_digest = sort_by_digest_4_4;
9473 opti_type = OPTI_TYPE_ZERO_BYTE
9474 | OPTI_TYPE_PRECOMPUTE_INIT
9475 | OPTI_TYPE_NOT_ITERATED;
9476 dgst_pos0 = 0;
9477 dgst_pos1 = 1;
9478 dgst_pos2 = 2;
9479 dgst_pos3 = 3;
9480 break;
9481
9482 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9483 salt_type = SALT_TYPE_EMBEDDED;
9484 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9485 opts_type = OPTS_TYPE_PT_GENERATE_LE
9486 | OPTS_TYPE_PT_ADD80
9487 | OPTS_TYPE_PT_UNICODE
9488 | OPTS_TYPE_PT_NEVERCRACK;
9489 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9490 dgst_size = DGST_SIZE_4_4;
9491 parse_func = oldoffice01cm2_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 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9503 salt_type = SALT_TYPE_EMBEDDED;
9504 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9505 opts_type = OPTS_TYPE_PT_GENERATE_BE
9506 | OPTS_TYPE_PT_ADD80
9507 | OPTS_TYPE_PT_UNICODE;
9508 kern_type = KERN_TYPE_OLDOFFICE34;
9509 dgst_size = DGST_SIZE_4_4;
9510 parse_func = oldoffice34_parse_hash;
9511 sort_by_digest = sort_by_digest_4_4;
9512 opti_type = OPTI_TYPE_ZERO_BYTE
9513 | OPTI_TYPE_PRECOMPUTE_INIT
9514 | OPTI_TYPE_NOT_ITERATED;
9515 dgst_pos0 = 0;
9516 dgst_pos1 = 1;
9517 dgst_pos2 = 2;
9518 dgst_pos3 = 3;
9519 break;
9520
9521 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9522 salt_type = SALT_TYPE_EMBEDDED;
9523 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9524 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9525 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9526 dgst_size = DGST_SIZE_4_4;
9527 parse_func = oldoffice34cm1_parse_hash;
9528 sort_by_digest = sort_by_digest_4_4;
9529 opti_type = OPTI_TYPE_ZERO_BYTE
9530 | OPTI_TYPE_PRECOMPUTE_INIT
9531 | OPTI_TYPE_NOT_ITERATED;
9532 dgst_pos0 = 0;
9533 dgst_pos1 = 1;
9534 dgst_pos2 = 2;
9535 dgst_pos3 = 3;
9536 break;
9537
9538 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9539 salt_type = SALT_TYPE_EMBEDDED;
9540 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9541 opts_type = OPTS_TYPE_PT_GENERATE_BE
9542 | OPTS_TYPE_PT_ADD80
9543 | OPTS_TYPE_PT_UNICODE
9544 | OPTS_TYPE_PT_NEVERCRACK;
9545 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9546 dgst_size = DGST_SIZE_4_4;
9547 parse_func = oldoffice34cm2_parse_hash;
9548 sort_by_digest = sort_by_digest_4_4;
9549 opti_type = OPTI_TYPE_ZERO_BYTE
9550 | OPTI_TYPE_PRECOMPUTE_INIT
9551 | OPTI_TYPE_NOT_ITERATED;
9552 dgst_pos0 = 0;
9553 dgst_pos1 = 1;
9554 dgst_pos2 = 2;
9555 dgst_pos3 = 3;
9556 break;
9557
9558 case 9900: hash_type = HASH_TYPE_MD5;
9559 salt_type = SALT_TYPE_NONE;
9560 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9561 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9562 kern_type = KERN_TYPE_RADMIN2;
9563 dgst_size = DGST_SIZE_4_4;
9564 parse_func = radmin2_parse_hash;
9565 sort_by_digest = sort_by_digest_4_4;
9566 opti_type = OPTI_TYPE_ZERO_BYTE
9567 | OPTI_TYPE_PRECOMPUTE_INIT
9568 | OPTI_TYPE_EARLY_SKIP
9569 | OPTI_TYPE_NOT_ITERATED
9570 | OPTI_TYPE_NOT_SALTED;
9571 dgst_pos0 = 0;
9572 dgst_pos1 = 3;
9573 dgst_pos2 = 2;
9574 dgst_pos3 = 1;
9575 break;
9576
9577 case 10000: hash_type = HASH_TYPE_SHA256;
9578 salt_type = SALT_TYPE_EMBEDDED;
9579 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9580 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9581 kern_type = KERN_TYPE_PBKDF2_SHA256;
9582 dgst_size = DGST_SIZE_4_32;
9583 parse_func = djangopbkdf2_parse_hash;
9584 sort_by_digest = sort_by_digest_4_32;
9585 opti_type = OPTI_TYPE_ZERO_BYTE;
9586 dgst_pos0 = 0;
9587 dgst_pos1 = 1;
9588 dgst_pos2 = 2;
9589 dgst_pos3 = 3;
9590 break;
9591
9592 case 10100: hash_type = HASH_TYPE_SIPHASH;
9593 salt_type = SALT_TYPE_EMBEDDED;
9594 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9595 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9596 kern_type = KERN_TYPE_SIPHASH;
9597 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9598 parse_func = siphash_parse_hash;
9599 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9600 opti_type = OPTI_TYPE_ZERO_BYTE
9601 | OPTI_TYPE_NOT_ITERATED
9602 | OPTI_TYPE_RAW_HASH;
9603 dgst_pos0 = 0;
9604 dgst_pos1 = 1;
9605 dgst_pos2 = 2;
9606 dgst_pos3 = 3;
9607 break;
9608
9609 case 10200: hash_type = HASH_TYPE_MD5;
9610 salt_type = SALT_TYPE_EMBEDDED;
9611 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9612 opts_type = OPTS_TYPE_PT_GENERATE_LE
9613 | OPTS_TYPE_ST_ADD80
9614 | OPTS_TYPE_ST_ADDBITS14;
9615 kern_type = KERN_TYPE_HMACMD5_PW;
9616 dgst_size = DGST_SIZE_4_4;
9617 parse_func = crammd5_parse_hash;
9618 sort_by_digest = sort_by_digest_4_4;
9619 opti_type = OPTI_TYPE_ZERO_BYTE
9620 | OPTI_TYPE_NOT_ITERATED;
9621 dgst_pos0 = 0;
9622 dgst_pos1 = 3;
9623 dgst_pos2 = 2;
9624 dgst_pos3 = 1;
9625 break;
9626
9627 case 10300: hash_type = HASH_TYPE_SHA1;
9628 salt_type = SALT_TYPE_EMBEDDED;
9629 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9630 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9631 kern_type = KERN_TYPE_SAPH_SHA1;
9632 dgst_size = DGST_SIZE_4_5;
9633 parse_func = saph_sha1_parse_hash;
9634 sort_by_digest = sort_by_digest_4_5;
9635 opti_type = OPTI_TYPE_ZERO_BYTE;
9636 dgst_pos0 = 0;
9637 dgst_pos1 = 1;
9638 dgst_pos2 = 2;
9639 dgst_pos3 = 3;
9640 break;
9641
9642 case 10400: hash_type = HASH_TYPE_PDFU16;
9643 salt_type = SALT_TYPE_EMBEDDED;
9644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9645 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9646 kern_type = KERN_TYPE_PDF11;
9647 dgst_size = DGST_SIZE_4_4;
9648 parse_func = pdf11_parse_hash;
9649 sort_by_digest = sort_by_digest_4_4;
9650 opti_type = OPTI_TYPE_ZERO_BYTE
9651 | OPTI_TYPE_NOT_ITERATED;
9652 dgst_pos0 = 0;
9653 dgst_pos1 = 1;
9654 dgst_pos2 = 2;
9655 dgst_pos3 = 3;
9656 break;
9657
9658 case 10410: hash_type = HASH_TYPE_PDFU16;
9659 salt_type = SALT_TYPE_EMBEDDED;
9660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9661 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9662 kern_type = KERN_TYPE_PDF11CM1;
9663 dgst_size = DGST_SIZE_4_4;
9664 parse_func = pdf11cm1_parse_hash;
9665 sort_by_digest = sort_by_digest_4_4;
9666 opti_type = OPTI_TYPE_ZERO_BYTE
9667 | OPTI_TYPE_NOT_ITERATED;
9668 dgst_pos0 = 0;
9669 dgst_pos1 = 1;
9670 dgst_pos2 = 2;
9671 dgst_pos3 = 3;
9672 break;
9673
9674 case 10420: hash_type = HASH_TYPE_PDFU16;
9675 salt_type = SALT_TYPE_EMBEDDED;
9676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9677 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9678 kern_type = KERN_TYPE_PDF11CM2;
9679 dgst_size = DGST_SIZE_4_4;
9680 parse_func = pdf11cm2_parse_hash;
9681 sort_by_digest = sort_by_digest_4_4;
9682 opti_type = OPTI_TYPE_ZERO_BYTE
9683 | OPTI_TYPE_NOT_ITERATED;
9684 dgst_pos0 = 0;
9685 dgst_pos1 = 1;
9686 dgst_pos2 = 2;
9687 dgst_pos3 = 3;
9688 break;
9689
9690 case 10500: hash_type = HASH_TYPE_PDFU16;
9691 salt_type = SALT_TYPE_EMBEDDED;
9692 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9693 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9694 kern_type = KERN_TYPE_PDF14;
9695 dgst_size = DGST_SIZE_4_4;
9696 parse_func = pdf14_parse_hash;
9697 sort_by_digest = sort_by_digest_4_4;
9698 opti_type = OPTI_TYPE_ZERO_BYTE
9699 | OPTI_TYPE_NOT_ITERATED;
9700 dgst_pos0 = 0;
9701 dgst_pos1 = 1;
9702 dgst_pos2 = 2;
9703 dgst_pos3 = 3;
9704 break;
9705
9706 case 10600: hash_type = HASH_TYPE_SHA256;
9707 salt_type = SALT_TYPE_EMBEDDED;
9708 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9709 opts_type = OPTS_TYPE_PT_GENERATE_BE
9710 | OPTS_TYPE_ST_ADD80
9711 | OPTS_TYPE_ST_ADDBITS15
9712 | OPTS_TYPE_HASH_COPY;
9713 kern_type = KERN_TYPE_SHA256_PWSLT;
9714 dgst_size = DGST_SIZE_4_8;
9715 parse_func = pdf17l3_parse_hash;
9716 sort_by_digest = sort_by_digest_4_8;
9717 opti_type = OPTI_TYPE_ZERO_BYTE
9718 | OPTI_TYPE_PRECOMPUTE_INIT
9719 | OPTI_TYPE_PRECOMPUTE_MERKLE
9720 | OPTI_TYPE_EARLY_SKIP
9721 | OPTI_TYPE_NOT_ITERATED
9722 | OPTI_TYPE_APPENDED_SALT
9723 | OPTI_TYPE_RAW_HASH;
9724 dgst_pos0 = 3;
9725 dgst_pos1 = 7;
9726 dgst_pos2 = 2;
9727 dgst_pos3 = 6;
9728 break;
9729
9730 case 10700: hash_type = HASH_TYPE_PDFU32;
9731 salt_type = SALT_TYPE_EMBEDDED;
9732 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9733 opts_type = OPTS_TYPE_PT_GENERATE_LE
9734 | OPTS_TYPE_HASH_COPY;
9735 kern_type = KERN_TYPE_PDF17L8;
9736 dgst_size = DGST_SIZE_4_8;
9737 parse_func = pdf17l8_parse_hash;
9738 sort_by_digest = sort_by_digest_4_8;
9739 opti_type = OPTI_TYPE_ZERO_BYTE
9740 | OPTI_TYPE_NOT_ITERATED;
9741 dgst_pos0 = 0;
9742 dgst_pos1 = 1;
9743 dgst_pos2 = 2;
9744 dgst_pos3 = 3;
9745 break;
9746
9747 case 10800: hash_type = HASH_TYPE_SHA384;
9748 salt_type = SALT_TYPE_NONE;
9749 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9750 opts_type = OPTS_TYPE_PT_GENERATE_BE
9751 | OPTS_TYPE_PT_ADD80
9752 | OPTS_TYPE_PT_ADDBITS15;
9753 kern_type = KERN_TYPE_SHA384;
9754 dgst_size = DGST_SIZE_8_8;
9755 parse_func = sha384_parse_hash;
9756 sort_by_digest = sort_by_digest_8_8;
9757 opti_type = OPTI_TYPE_ZERO_BYTE
9758 | OPTI_TYPE_PRECOMPUTE_INIT
9759 | OPTI_TYPE_PRECOMPUTE_MERKLE
9760 | OPTI_TYPE_EARLY_SKIP
9761 | OPTI_TYPE_NOT_ITERATED
9762 | OPTI_TYPE_NOT_SALTED
9763 | OPTI_TYPE_USES_BITS_64
9764 | OPTI_TYPE_RAW_HASH;
9765 dgst_pos0 = 6;
9766 dgst_pos1 = 7;
9767 dgst_pos2 = 4;
9768 dgst_pos3 = 5;
9769 break;
9770
9771 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9772 salt_type = SALT_TYPE_EMBEDDED;
9773 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9774 opts_type = OPTS_TYPE_PT_GENERATE_LE
9775 | OPTS_TYPE_ST_BASE64
9776 | OPTS_TYPE_HASH_COPY;
9777 kern_type = KERN_TYPE_PBKDF2_SHA256;
9778 dgst_size = DGST_SIZE_4_32;
9779 parse_func = pbkdf2_sha256_parse_hash;
9780 sort_by_digest = sort_by_digest_4_32;
9781 opti_type = OPTI_TYPE_ZERO_BYTE;
9782 dgst_pos0 = 0;
9783 dgst_pos1 = 1;
9784 dgst_pos2 = 2;
9785 dgst_pos3 = 3;
9786 break;
9787
9788 case 11000: hash_type = HASH_TYPE_MD5;
9789 salt_type = SALT_TYPE_INTERN;
9790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9791 opts_type = OPTS_TYPE_PT_GENERATE_LE
9792 | OPTS_TYPE_PT_ADD80;
9793 kern_type = KERN_TYPE_PRESTASHOP;
9794 dgst_size = DGST_SIZE_4_4;
9795 parse_func = prestashop_parse_hash;
9796 sort_by_digest = sort_by_digest_4_4;
9797 opti_type = OPTI_TYPE_ZERO_BYTE
9798 | OPTI_TYPE_PRECOMPUTE_INIT
9799 | OPTI_TYPE_NOT_ITERATED
9800 | OPTI_TYPE_PREPENDED_SALT;
9801 dgst_pos0 = 0;
9802 dgst_pos1 = 3;
9803 dgst_pos2 = 2;
9804 dgst_pos3 = 1;
9805 break;
9806
9807 case 11100: hash_type = HASH_TYPE_MD5;
9808 salt_type = SALT_TYPE_EMBEDDED;
9809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9810 opts_type = OPTS_TYPE_PT_GENERATE_LE
9811 | OPTS_TYPE_ST_ADD80;
9812 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9813 dgst_size = DGST_SIZE_4_4;
9814 parse_func = postgresql_auth_parse_hash;
9815 sort_by_digest = sort_by_digest_4_4;
9816 opti_type = OPTI_TYPE_ZERO_BYTE
9817 | OPTI_TYPE_PRECOMPUTE_INIT
9818 | OPTI_TYPE_PRECOMPUTE_MERKLE
9819 | OPTI_TYPE_EARLY_SKIP;
9820 dgst_pos0 = 0;
9821 dgst_pos1 = 3;
9822 dgst_pos2 = 2;
9823 dgst_pos3 = 1;
9824 break;
9825
9826 case 11200: hash_type = HASH_TYPE_SHA1;
9827 salt_type = SALT_TYPE_EMBEDDED;
9828 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9829 opts_type = OPTS_TYPE_PT_GENERATE_BE
9830 | OPTS_TYPE_PT_ADD80
9831 | OPTS_TYPE_ST_HEX;
9832 kern_type = KERN_TYPE_MYSQL_AUTH;
9833 dgst_size = DGST_SIZE_4_5;
9834 parse_func = mysql_auth_parse_hash;
9835 sort_by_digest = sort_by_digest_4_5;
9836 opti_type = OPTI_TYPE_ZERO_BYTE
9837 | OPTI_TYPE_EARLY_SKIP;
9838 dgst_pos0 = 3;
9839 dgst_pos1 = 4;
9840 dgst_pos2 = 2;
9841 dgst_pos3 = 1;
9842 break;
9843
9844 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9845 salt_type = SALT_TYPE_EMBEDDED;
9846 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9847 opts_type = OPTS_TYPE_PT_GENERATE_LE
9848 | OPTS_TYPE_ST_HEX
9849 | OPTS_TYPE_ST_ADD80;
9850 kern_type = KERN_TYPE_BITCOIN_WALLET;
9851 dgst_size = DGST_SIZE_4_4;
9852 parse_func = bitcoin_wallet_parse_hash;
9853 sort_by_digest = sort_by_digest_4_4;
9854 opti_type = OPTI_TYPE_ZERO_BYTE;
9855 dgst_pos0 = 0;
9856 dgst_pos1 = 1;
9857 dgst_pos2 = 2;
9858 dgst_pos3 = 3;
9859 break;
9860
9861 case 11400: hash_type = HASH_TYPE_MD5;
9862 salt_type = SALT_TYPE_EMBEDDED;
9863 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9864 opts_type = OPTS_TYPE_PT_GENERATE_LE
9865 | OPTS_TYPE_PT_ADD80
9866 | OPTS_TYPE_HASH_COPY;
9867 kern_type = KERN_TYPE_SIP_AUTH;
9868 dgst_size = DGST_SIZE_4_4;
9869 parse_func = sip_auth_parse_hash;
9870 sort_by_digest = sort_by_digest_4_4;
9871 opti_type = OPTI_TYPE_ZERO_BYTE;
9872 dgst_pos0 = 0;
9873 dgst_pos1 = 3;
9874 dgst_pos2 = 2;
9875 dgst_pos3 = 1;
9876 break;
9877
9878 case 11500: hash_type = HASH_TYPE_CRC32;
9879 salt_type = SALT_TYPE_INTERN;
9880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9881 opts_type = OPTS_TYPE_PT_GENERATE_LE
9882 | OPTS_TYPE_ST_GENERATE_LE
9883 | OPTS_TYPE_ST_HEX;
9884 kern_type = KERN_TYPE_CRC32;
9885 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9886 parse_func = crc32_parse_hash;
9887 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9888 opti_type = OPTI_TYPE_ZERO_BYTE;
9889 dgst_pos0 = 0;
9890 dgst_pos1 = 1;
9891 dgst_pos2 = 2;
9892 dgst_pos3 = 3;
9893 break;
9894
9895 case 11600: hash_type = HASH_TYPE_AES;
9896 salt_type = SALT_TYPE_EMBEDDED;
9897 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9898 opts_type = OPTS_TYPE_PT_GENERATE_LE
9899 | OPTS_TYPE_PT_NEVERCRACK;
9900 kern_type = KERN_TYPE_SEVEN_ZIP;
9901 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9902 parse_func = seven_zip_parse_hash;
9903 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9904 opti_type = OPTI_TYPE_ZERO_BYTE;
9905 dgst_pos0 = 0;
9906 dgst_pos1 = 1;
9907 dgst_pos2 = 2;
9908 dgst_pos3 = 3;
9909 break;
9910
9911 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9912 salt_type = SALT_TYPE_NONE;
9913 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9914 opts_type = OPTS_TYPE_PT_GENERATE_LE
9915 | OPTS_TYPE_PT_ADD01;
9916 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9917 dgst_size = DGST_SIZE_4_8;
9918 parse_func = gost2012sbog_256_parse_hash;
9919 sort_by_digest = sort_by_digest_4_8;
9920 opti_type = OPTI_TYPE_ZERO_BYTE;
9921 dgst_pos0 = 0;
9922 dgst_pos1 = 1;
9923 dgst_pos2 = 2;
9924 dgst_pos3 = 3;
9925 break;
9926
9927 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9928 salt_type = SALT_TYPE_NONE;
9929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9930 opts_type = OPTS_TYPE_PT_GENERATE_LE
9931 | OPTS_TYPE_PT_ADD01;
9932 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9933 dgst_size = DGST_SIZE_4_16;
9934 parse_func = gost2012sbog_512_parse_hash;
9935 sort_by_digest = sort_by_digest_4_16;
9936 opti_type = OPTI_TYPE_ZERO_BYTE;
9937 dgst_pos0 = 0;
9938 dgst_pos1 = 1;
9939 dgst_pos2 = 2;
9940 dgst_pos3 = 3;
9941 break;
9942
9943 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9944 salt_type = SALT_TYPE_EMBEDDED;
9945 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9946 opts_type = OPTS_TYPE_PT_GENERATE_LE
9947 | OPTS_TYPE_ST_BASE64
9948 | OPTS_TYPE_HASH_COPY;
9949 kern_type = KERN_TYPE_PBKDF2_MD5;
9950 dgst_size = DGST_SIZE_4_32;
9951 parse_func = pbkdf2_md5_parse_hash;
9952 sort_by_digest = sort_by_digest_4_32;
9953 opti_type = OPTI_TYPE_ZERO_BYTE;
9954 dgst_pos0 = 0;
9955 dgst_pos1 = 1;
9956 dgst_pos2 = 2;
9957 dgst_pos3 = 3;
9958 break;
9959
9960 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9961 salt_type = SALT_TYPE_EMBEDDED;
9962 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9963 opts_type = OPTS_TYPE_PT_GENERATE_LE
9964 | OPTS_TYPE_ST_BASE64
9965 | OPTS_TYPE_HASH_COPY;
9966 kern_type = KERN_TYPE_PBKDF2_SHA1;
9967 dgst_size = DGST_SIZE_4_32;
9968 parse_func = pbkdf2_sha1_parse_hash;
9969 sort_by_digest = sort_by_digest_4_32;
9970 opti_type = OPTI_TYPE_ZERO_BYTE;
9971 dgst_pos0 = 0;
9972 dgst_pos1 = 1;
9973 dgst_pos2 = 2;
9974 dgst_pos3 = 3;
9975 break;
9976
9977 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9978 salt_type = SALT_TYPE_EMBEDDED;
9979 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9980 opts_type = OPTS_TYPE_PT_GENERATE_LE
9981 | OPTS_TYPE_ST_BASE64
9982 | OPTS_TYPE_HASH_COPY;
9983 kern_type = KERN_TYPE_PBKDF2_SHA512;
9984 dgst_size = DGST_SIZE_8_16;
9985 parse_func = pbkdf2_sha512_parse_hash;
9986 sort_by_digest = sort_by_digest_8_16;
9987 opti_type = OPTI_TYPE_ZERO_BYTE
9988 | OPTI_TYPE_USES_BITS_64;
9989 dgst_pos0 = 0;
9990 dgst_pos1 = 1;
9991 dgst_pos2 = 2;
9992 dgst_pos3 = 3;
9993 break;
9994
9995 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9996 salt_type = SALT_TYPE_EMBEDDED;
9997 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9998 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9999 kern_type = KERN_TYPE_ECRYPTFS;
10000 dgst_size = DGST_SIZE_8_8;
10001 parse_func = ecryptfs_parse_hash;
10002 sort_by_digest = sort_by_digest_8_8;
10003 opti_type = OPTI_TYPE_ZERO_BYTE
10004 | OPTI_TYPE_USES_BITS_64;
10005 dgst_pos0 = 0;
10006 dgst_pos1 = 1;
10007 dgst_pos2 = 2;
10008 dgst_pos3 = 3;
10009 break;
10010
10011 case 12300: hash_type = HASH_TYPE_ORACLET;
10012 salt_type = SALT_TYPE_EMBEDDED;
10013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10014 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10015 kern_type = KERN_TYPE_ORACLET;
10016 dgst_size = DGST_SIZE_8_16;
10017 parse_func = oraclet_parse_hash;
10018 sort_by_digest = sort_by_digest_8_16;
10019 opti_type = OPTI_TYPE_ZERO_BYTE
10020 | OPTI_TYPE_USES_BITS_64;
10021 dgst_pos0 = 0;
10022 dgst_pos1 = 1;
10023 dgst_pos2 = 2;
10024 dgst_pos3 = 3;
10025 break;
10026
10027 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10028 salt_type = SALT_TYPE_EMBEDDED;
10029 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10030 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10031 kern_type = KERN_TYPE_BSDICRYPT;
10032 dgst_size = DGST_SIZE_4_4;
10033 parse_func = bsdicrypt_parse_hash;
10034 sort_by_digest = sort_by_digest_4_4;
10035 opti_type = OPTI_TYPE_ZERO_BYTE
10036 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10037 dgst_pos0 = 0;
10038 dgst_pos1 = 1;
10039 dgst_pos2 = 2;
10040 dgst_pos3 = 3;
10041 break;
10042
10043 case 12500: hash_type = HASH_TYPE_RAR3HP;
10044 salt_type = SALT_TYPE_EMBEDDED;
10045 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10046 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10047 kern_type = KERN_TYPE_RAR3;
10048 dgst_size = DGST_SIZE_4_4;
10049 parse_func = rar3hp_parse_hash;
10050 sort_by_digest = sort_by_digest_4_4;
10051 opti_type = OPTI_TYPE_ZERO_BYTE;
10052 dgst_pos0 = 0;
10053 dgst_pos1 = 1;
10054 dgst_pos2 = 2;
10055 dgst_pos3 = 3;
10056 break;
10057
10058 case 12600: hash_type = HASH_TYPE_SHA256;
10059 salt_type = SALT_TYPE_INTERN;
10060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10061 opts_type = OPTS_TYPE_PT_GENERATE_BE
10062 | OPTS_TYPE_PT_ADD80;
10063 kern_type = KERN_TYPE_CF10;
10064 dgst_size = DGST_SIZE_4_8;
10065 parse_func = cf10_parse_hash;
10066 sort_by_digest = sort_by_digest_4_8;
10067 opti_type = OPTI_TYPE_ZERO_BYTE
10068 | OPTI_TYPE_PRECOMPUTE_INIT
10069 | OPTI_TYPE_EARLY_SKIP
10070 | OPTI_TYPE_NOT_ITERATED;
10071 dgst_pos0 = 3;
10072 dgst_pos1 = 7;
10073 dgst_pos2 = 2;
10074 dgst_pos3 = 6;
10075 break;
10076
10077 case 12700: hash_type = HASH_TYPE_AES;
10078 salt_type = SALT_TYPE_EMBEDDED;
10079 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10080 opts_type = OPTS_TYPE_PT_GENERATE_LE
10081 | OPTS_TYPE_HASH_COPY;
10082 kern_type = KERN_TYPE_MYWALLET;
10083 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10084 parse_func = mywallet_parse_hash;
10085 sort_by_digest = sort_by_digest_4_5;
10086 opti_type = OPTI_TYPE_ZERO_BYTE;
10087 dgst_pos0 = 0;
10088 dgst_pos1 = 1;
10089 dgst_pos2 = 2;
10090 dgst_pos3 = 3;
10091 break;
10092
10093 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10094 salt_type = SALT_TYPE_EMBEDDED;
10095 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10096 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10097 kern_type = KERN_TYPE_MS_DRSR;
10098 dgst_size = DGST_SIZE_4_8;
10099 parse_func = ms_drsr_parse_hash;
10100 sort_by_digest = sort_by_digest_4_8;
10101 opti_type = OPTI_TYPE_ZERO_BYTE;
10102 dgst_pos0 = 0;
10103 dgst_pos1 = 1;
10104 dgst_pos2 = 2;
10105 dgst_pos3 = 3;
10106 break;
10107
10108 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10109 salt_type = SALT_TYPE_EMBEDDED;
10110 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10111 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10112 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10113 dgst_size = DGST_SIZE_4_8;
10114 parse_func = androidfde_samsung_parse_hash;
10115 sort_by_digest = sort_by_digest_4_8;
10116 opti_type = OPTI_TYPE_ZERO_BYTE;
10117 dgst_pos0 = 0;
10118 dgst_pos1 = 1;
10119 dgst_pos2 = 2;
10120 dgst_pos3 = 3;
10121 break;
10122
10123 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10124 salt_type = SALT_TYPE_EMBEDDED;
10125 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10126 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10127 kern_type = KERN_TYPE_RAR5;
10128 dgst_size = DGST_SIZE_4_4;
10129 parse_func = rar5_parse_hash;
10130 sort_by_digest = sort_by_digest_4_4;
10131 opti_type = OPTI_TYPE_ZERO_BYTE;
10132 dgst_pos0 = 0;
10133 dgst_pos1 = 1;
10134 dgst_pos2 = 2;
10135 dgst_pos3 = 3;
10136 break;
10137
10138 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10139 salt_type = SALT_TYPE_EMBEDDED;
10140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10141 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10142 kern_type = KERN_TYPE_KRB5TGS;
10143 dgst_size = DGST_SIZE_4_4;
10144 parse_func = krb5tgs_parse_hash;
10145 sort_by_digest = sort_by_digest_4_4;
10146 opti_type = OPTI_TYPE_ZERO_BYTE
10147 | OPTI_TYPE_NOT_ITERATED;
10148 dgst_pos0 = 0;
10149 dgst_pos1 = 1;
10150 dgst_pos2 = 2;
10151 dgst_pos3 = 3;
10152 break;
10153
10154 case 13200: hash_type = HASH_TYPE_AES;
10155 salt_type = SALT_TYPE_EMBEDDED;
10156 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10157 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10158 kern_type = KERN_TYPE_AXCRYPT;
10159 dgst_size = DGST_SIZE_4_4;
10160 parse_func = axcrypt_parse_hash;
10161 sort_by_digest = sort_by_digest_4_4;
10162 opti_type = OPTI_TYPE_ZERO_BYTE;
10163 dgst_pos0 = 0;
10164 dgst_pos1 = 1;
10165 dgst_pos2 = 2;
10166 dgst_pos3 = 3;
10167 break;
10168
10169 case 13300: hash_type = HASH_TYPE_SHA1;
10170 salt_type = SALT_TYPE_NONE;
10171 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10172 opts_type = OPTS_TYPE_PT_GENERATE_BE
10173 | OPTS_TYPE_PT_ADD80
10174 | OPTS_TYPE_PT_ADDBITS15;
10175 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10176 dgst_size = DGST_SIZE_4_5;
10177 parse_func = sha1axcrypt_parse_hash;
10178 sort_by_digest = sort_by_digest_4_5;
10179 opti_type = OPTI_TYPE_ZERO_BYTE
10180 | OPTI_TYPE_PRECOMPUTE_INIT
10181 | OPTI_TYPE_EARLY_SKIP
10182 | OPTI_TYPE_NOT_ITERATED
10183 | OPTI_TYPE_NOT_SALTED;
10184 dgst_pos0 = 0;
10185 dgst_pos1 = 4;
10186 dgst_pos2 = 3;
10187 dgst_pos3 = 2;
10188 break;
10189
10190 case 13400: hash_type = HASH_TYPE_AES;
10191 salt_type = SALT_TYPE_EMBEDDED;
10192 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10193 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10194 kern_type = KERN_TYPE_KEEPASS;
10195 dgst_size = DGST_SIZE_4_4;
10196 parse_func = keepass_parse_hash;
10197 sort_by_digest = sort_by_digest_4_4;
10198 opti_type = OPTI_TYPE_ZERO_BYTE;
10199 dgst_pos0 = 0;
10200 dgst_pos1 = 1;
10201 dgst_pos2 = 2;
10202 dgst_pos3 = 3;
10203 break;
10204
10205 case 13500: hash_type = HASH_TYPE_SHA1;
10206 salt_type = SALT_TYPE_EMBEDDED;
10207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10208 opts_type = OPTS_TYPE_PT_GENERATE_BE
10209 | OPTS_TYPE_PT_UNICODE
10210 | OPTS_TYPE_PT_ADD80;
10211 kern_type = KERN_TYPE_PSTOKEN;
10212 dgst_size = DGST_SIZE_4_5;
10213 parse_func = pstoken_parse_hash;
10214 sort_by_digest = sort_by_digest_4_5;
10215 opti_type = OPTI_TYPE_ZERO_BYTE
10216 | OPTI_TYPE_PRECOMPUTE_INIT
10217 | OPTI_TYPE_EARLY_SKIP
10218 | OPTI_TYPE_NOT_ITERATED
10219 | OPTI_TYPE_PREPENDED_SALT
10220 | OPTI_TYPE_RAW_HASH;
10221 dgst_pos0 = 3;
10222 dgst_pos1 = 4;
10223 dgst_pos2 = 2;
10224 dgst_pos3 = 1;
10225 break;
10226
10227 default: usage_mini_print (PROGNAME); return (-1);
10228 }
10229
10230 /**
10231 * parser
10232 */
10233
10234 data.parse_func = parse_func;
10235
10236 /**
10237 * misc stuff
10238 */
10239
10240 if (hex_salt)
10241 {
10242 if (salt_type == SALT_TYPE_INTERN)
10243 {
10244 opts_type |= OPTS_TYPE_ST_HEX;
10245 }
10246 else
10247 {
10248 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10249
10250 return (-1);
10251 }
10252 }
10253
10254 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10255 | (salt_type == SALT_TYPE_EXTERN)
10256 | (salt_type == SALT_TYPE_EMBEDDED)
10257 | (salt_type == SALT_TYPE_VIRTUAL));
10258
10259 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10260
10261 data.hash_type = hash_type;
10262 data.attack_mode = attack_mode;
10263 data.attack_kern = attack_kern;
10264 data.attack_exec = attack_exec;
10265 data.kern_type = kern_type;
10266 data.opts_type = opts_type;
10267 data.dgst_size = dgst_size;
10268 data.salt_type = salt_type;
10269 data.isSalted = isSalted;
10270 data.sort_by_digest = sort_by_digest;
10271 data.dgst_pos0 = dgst_pos0;
10272 data.dgst_pos1 = dgst_pos1;
10273 data.dgst_pos2 = dgst_pos2;
10274 data.dgst_pos3 = dgst_pos3;
10275
10276 esalt_size = 0;
10277
10278 switch (hash_mode)
10279 {
10280 case 2500: esalt_size = sizeof (wpa_t); break;
10281 case 5300: esalt_size = sizeof (ikepsk_t); break;
10282 case 5400: esalt_size = sizeof (ikepsk_t); break;
10283 case 5500: esalt_size = sizeof (netntlm_t); break;
10284 case 5600: esalt_size = sizeof (netntlm_t); break;
10285 case 6211: esalt_size = sizeof (tc_t); break;
10286 case 6212: esalt_size = sizeof (tc_t); break;
10287 case 6213: esalt_size = sizeof (tc_t); break;
10288 case 6221: esalt_size = sizeof (tc_t); break;
10289 case 6222: esalt_size = sizeof (tc_t); break;
10290 case 6223: esalt_size = sizeof (tc_t); break;
10291 case 6231: esalt_size = sizeof (tc_t); break;
10292 case 6232: esalt_size = sizeof (tc_t); break;
10293 case 6233: esalt_size = sizeof (tc_t); break;
10294 case 6241: esalt_size = sizeof (tc_t); break;
10295 case 6242: esalt_size = sizeof (tc_t); break;
10296 case 6243: esalt_size = sizeof (tc_t); break;
10297 case 6600: esalt_size = sizeof (agilekey_t); break;
10298 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10299 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10300 case 7300: esalt_size = sizeof (rakp_t); break;
10301 case 7500: esalt_size = sizeof (krb5pa_t); break;
10302 case 8200: esalt_size = sizeof (cloudkey_t); break;
10303 case 8800: esalt_size = sizeof (androidfde_t); break;
10304 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10305 case 9400: esalt_size = sizeof (office2007_t); break;
10306 case 9500: esalt_size = sizeof (office2010_t); break;
10307 case 9600: esalt_size = sizeof (office2013_t); break;
10308 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10309 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10310 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10311 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10312 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10313 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10314 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10315 case 10200: esalt_size = sizeof (cram_md5_t); break;
10316 case 10400: esalt_size = sizeof (pdf_t); break;
10317 case 10410: esalt_size = sizeof (pdf_t); break;
10318 case 10420: esalt_size = sizeof (pdf_t); break;
10319 case 10500: esalt_size = sizeof (pdf_t); break;
10320 case 10600: esalt_size = sizeof (pdf_t); break;
10321 case 10700: esalt_size = sizeof (pdf_t); break;
10322 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10323 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10324 case 11400: esalt_size = sizeof (sip_t); break;
10325 case 11600: esalt_size = sizeof (seven_zip_t); break;
10326 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10327 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10328 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10329 case 13000: esalt_size = sizeof (rar5_t); break;
10330 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10331 case 13400: esalt_size = sizeof (keepass_t); break;
10332 case 13500: esalt_size = sizeof (pstoken_t); break;
10333 }
10334
10335 data.esalt_size = esalt_size;
10336
10337 /**
10338 * choose dictionary parser
10339 */
10340
10341 if (hash_type == HASH_TYPE_LM)
10342 {
10343 get_next_word_func = get_next_word_lm;
10344 }
10345 else if (opts_type & OPTS_TYPE_PT_UPPER)
10346 {
10347 get_next_word_func = get_next_word_uc;
10348 }
10349 else
10350 {
10351 get_next_word_func = get_next_word_std;
10352 }
10353
10354 /**
10355 * dictstat
10356 */
10357
10358 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10359
10360 #ifdef _POSIX
10361 size_t dictstat_nmemb = 0;
10362 #endif
10363
10364 #ifdef _WIN
10365 uint dictstat_nmemb = 0;
10366 #endif
10367
10368 char dictstat[256] = { 0 };
10369
10370 FILE *dictstat_fp = NULL;
10371
10372 if (keyspace == 0)
10373 {
10374 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10375
10376 dictstat_fp = fopen (dictstat, "rb");
10377
10378 if (dictstat_fp)
10379 {
10380 #ifdef _POSIX
10381 struct stat tmpstat;
10382
10383 fstat (fileno (dictstat_fp), &tmpstat);
10384 #endif
10385
10386 #ifdef _WIN
10387 struct stat64 tmpstat;
10388
10389 _fstat64 (fileno (dictstat_fp), &tmpstat);
10390 #endif
10391
10392 if (tmpstat.st_mtime < COMPTIME)
10393 {
10394 /* with v0.15 the format changed so we have to ensure user is using a good version
10395 since there is no version-header in the dictstat file */
10396
10397 fclose (dictstat_fp);
10398
10399 unlink (dictstat);
10400 }
10401 else
10402 {
10403 while (!feof (dictstat_fp))
10404 {
10405 dictstat_t d;
10406
10407 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10408
10409 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10410
10411 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10412 {
10413 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10414
10415 return -1;
10416 }
10417 }
10418
10419 fclose (dictstat_fp);
10420 }
10421 }
10422 }
10423
10424 /**
10425 * potfile
10426 */
10427
10428 char potfile[256] = { 0 };
10429
10430 if (potfile_path == NULL)
10431 {
10432 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10433 }
10434 else
10435 {
10436 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10437 }
10438
10439 data.pot_fp = NULL;
10440
10441 FILE *out_fp = NULL;
10442 FILE *pot_fp = NULL;
10443
10444 if (show == 1 || left == 1)
10445 {
10446 pot_fp = fopen (potfile, "rb");
10447
10448 if (pot_fp == NULL)
10449 {
10450 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10451
10452 return (-1);
10453 }
10454
10455 if (outfile != NULL)
10456 {
10457 if ((out_fp = fopen (outfile, "ab")) == NULL)
10458 {
10459 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10460
10461 fclose (pot_fp);
10462
10463 return (-1);
10464 }
10465 }
10466 else
10467 {
10468 out_fp = stdout;
10469 }
10470 }
10471 else
10472 {
10473 if (potfile_disable == 0)
10474 {
10475 pot_fp = fopen (potfile, "ab");
10476
10477 if (pot_fp == NULL)
10478 {
10479 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10480
10481 return (-1);
10482 }
10483
10484 data.pot_fp = pot_fp;
10485 }
10486 }
10487
10488 pot_t *pot = NULL;
10489
10490 uint pot_cnt = 0;
10491 uint pot_avail = 0;
10492
10493 if (show == 1 || left == 1)
10494 {
10495 SUPPRESS_OUTPUT = 1;
10496
10497 pot_avail = count_lines (pot_fp);
10498
10499 rewind (pot_fp);
10500
10501 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10502
10503 uint pot_hashes_avail = 0;
10504
10505 uint line_num = 0;
10506
10507 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10508
10509 while (!feof (pot_fp))
10510 {
10511 line_num++;
10512
10513 int line_len = fgetl (pot_fp, line_buf);
10514
10515 if (line_len == 0) continue;
10516
10517 char *plain_buf = line_buf + line_len;
10518
10519 pot_t *pot_ptr = &pot[pot_cnt];
10520
10521 hash_t *hashes_buf = &pot_ptr->hash;
10522
10523 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10524 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10525
10526 if (pot_cnt == pot_hashes_avail)
10527 {
10528 uint pos = 0;
10529
10530 for (pos = 0; pos < INCR_POT; pos++)
10531 {
10532 if ((pot_cnt + pos) >= pot_avail) break;
10533
10534 pot_t *tmp_pot = &pot[pot_cnt + pos];
10535
10536 hash_t *tmp_hash = &tmp_pot->hash;
10537
10538 tmp_hash->digest = mymalloc (dgst_size);
10539
10540 if (isSalted)
10541 {
10542 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10543 }
10544
10545 if (esalt_size)
10546 {
10547 tmp_hash->esalt = mymalloc (esalt_size);
10548 }
10549
10550 pot_hashes_avail++;
10551 }
10552 }
10553
10554 int plain_len = 0;
10555
10556 int parser_status;
10557
10558 int iter = MAX_CUT_TRIES;
10559
10560 do
10561 {
10562 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10563 {
10564 if (line_buf[i] == ':')
10565 {
10566 line_len--;
10567
10568 break;
10569 }
10570 }
10571
10572 if (data.hash_mode != 2500)
10573 {
10574 parser_status = parse_func (line_buf, line_len, hashes_buf);
10575 }
10576 else
10577 {
10578 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10579
10580 if (line_len > max_salt_size)
10581 {
10582 parser_status = PARSER_GLOBAL_LENGTH;
10583 }
10584 else
10585 {
10586 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10587
10588 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10589
10590 hashes_buf->salt->salt_len = line_len;
10591
10592 parser_status = PARSER_OK;
10593 }
10594 }
10595
10596 // if NOT parsed without error, we add the ":" to the plain
10597
10598 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10599 {
10600 plain_len++;
10601 plain_buf--;
10602 }
10603
10604 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10605
10606 if (parser_status < PARSER_GLOBAL_ZERO)
10607 {
10608 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10609
10610 continue;
10611 }
10612
10613 if (plain_len >= 255) continue;
10614
10615 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10616
10617 pot_ptr->plain_len = plain_len;
10618
10619 pot_cnt++;
10620 }
10621
10622 myfree (line_buf);
10623
10624 fclose (pot_fp);
10625
10626 SUPPRESS_OUTPUT = 0;
10627
10628 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10629 }
10630
10631 /**
10632 * word len
10633 */
10634
10635 uint pw_min = PW_MIN;
10636 uint pw_max = PW_MAX;
10637
10638 switch (hash_mode)
10639 {
10640 case 125: if (pw_max > 32) pw_max = 32;
10641 break;
10642 case 400: if (pw_max > 40) pw_max = 40;
10643 break;
10644 case 500: if (pw_max > 16) pw_max = 16;
10645 break;
10646 case 1500: if (pw_max > 8) pw_max = 8;
10647 break;
10648 case 1600: if (pw_max > 16) pw_max = 16;
10649 break;
10650 case 1800: if (pw_max > 16) pw_max = 16;
10651 break;
10652 case 2100: if (pw_max > 16) pw_max = 16;
10653 break;
10654 case 2500: if (pw_min < 8) pw_min = 8;
10655 break;
10656 case 3000: if (pw_max > 7) pw_max = 7;
10657 break;
10658 case 5200: if (pw_max > 24) pw_max = 24;
10659 break;
10660 case 5800: if (pw_max > 16) pw_max = 16;
10661 break;
10662 case 6300: if (pw_max > 16) pw_max = 16;
10663 break;
10664 case 7400: if (pw_max > 16) pw_max = 16;
10665 break;
10666 case 7900: if (pw_max > 48) pw_max = 48;
10667 break;
10668 case 8500: if (pw_max > 8) pw_max = 8;
10669 break;
10670 case 8600: if (pw_max > 16) pw_max = 16;
10671 break;
10672 case 9710: pw_min = 5;
10673 pw_max = 5;
10674 break;
10675 case 9810: pw_min = 5;
10676 pw_max = 5;
10677 break;
10678 case 10410: pw_min = 5;
10679 pw_max = 5;
10680 break;
10681 case 10300: if (pw_max < 3) pw_min = 3;
10682 if (pw_max > 40) pw_max = 40;
10683 break;
10684 case 10500: if (pw_max < 3) pw_min = 3;
10685 if (pw_max > 40) pw_max = 40;
10686 break;
10687 case 10700: if (pw_max > 16) pw_max = 16;
10688 break;
10689 case 11300: if (pw_max > 40) pw_max = 40;
10690 break;
10691 case 12500: if (pw_max > 20) pw_max = 20;
10692 break;
10693 case 12800: if (pw_max > 24) pw_max = 24;
10694 break;
10695 }
10696
10697 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10698 {
10699 switch (attack_kern)
10700 {
10701 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10702 break;
10703 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10704 break;
10705 }
10706 }
10707
10708 /**
10709 * charsets : keep them together for more easy maintainnce
10710 */
10711
10712 cs_t mp_sys[6] = { { { 0 }, 0 } };
10713 cs_t mp_usr[4] = { { { 0 }, 0 } };
10714
10715 mp_setup_sys (mp_sys);
10716
10717 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10718 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10719 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10720 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10721
10722 /**
10723 * load hashes, part I: find input mode, count hashes
10724 */
10725
10726 uint hashlist_mode = 0;
10727 uint hashlist_format = HLFMT_HASHCAT;
10728
10729 uint hashes_avail = 0;
10730
10731 if (benchmark == 0)
10732 {
10733 struct stat f;
10734
10735 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10736
10737 if ((hash_mode == 2500) ||
10738 (hash_mode == 5200) ||
10739 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10740 (hash_mode == 9000))
10741 {
10742 hashlist_mode = HL_MODE_ARG;
10743
10744 char *hashfile = myargv[optind];
10745
10746 data.hashfile = hashfile;
10747
10748 logfile_top_var_string ("target", hashfile);
10749 }
10750
10751 if (hashlist_mode == HL_MODE_ARG)
10752 {
10753 if (hash_mode == 2500)
10754 {
10755 struct stat st;
10756
10757 if (stat (data.hashfile, &st) == -1)
10758 {
10759 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10760
10761 return (-1);
10762 }
10763
10764 hashes_avail = st.st_size / sizeof (hccap_t);
10765 }
10766 else
10767 {
10768 hashes_avail = 1;
10769 }
10770 }
10771 else if (hashlist_mode == HL_MODE_FILE)
10772 {
10773 char *hashfile = myargv[optind];
10774
10775 data.hashfile = hashfile;
10776
10777 logfile_top_var_string ("target", hashfile);
10778
10779 FILE *fp = NULL;
10780
10781 if ((fp = fopen (hashfile, "rb")) == NULL)
10782 {
10783 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10784
10785 return (-1);
10786 }
10787
10788 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10789
10790 hashes_avail = count_lines (fp);
10791
10792 rewind (fp);
10793
10794 if (hashes_avail == 0)
10795 {
10796 log_error ("ERROR: hashfile is empty or corrupt");
10797
10798 fclose (fp);
10799
10800 return (-1);
10801 }
10802
10803 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10804
10805 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10806 {
10807 log_error ("ERROR: remove not supported in native hashfile-format mode");
10808
10809 fclose (fp);
10810
10811 return (-1);
10812 }
10813
10814 fclose (fp);
10815 }
10816 }
10817 else
10818 {
10819 hashlist_mode = HL_MODE_ARG;
10820
10821 hashes_avail = 1;
10822 }
10823
10824 if (hash_mode == 3000) hashes_avail *= 2;
10825
10826 data.hashlist_mode = hashlist_mode;
10827 data.hashlist_format = hashlist_format;
10828
10829 logfile_top_uint (hashlist_mode);
10830 logfile_top_uint (hashlist_format);
10831
10832 /**
10833 * load hashes, part II: allocate required memory, set pointers
10834 */
10835
10836 hash_t *hashes_buf = NULL;
10837 void *digests_buf = NULL;
10838 salt_t *salts_buf = NULL;
10839 void *esalts_buf = NULL;
10840
10841 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10842
10843 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10844
10845 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10846 {
10847 u32 hash_pos;
10848
10849 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10850 {
10851 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10852
10853 hashes_buf[hash_pos].hash_info = hash_info;
10854
10855 if (username && (remove || show || left))
10856 {
10857 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10858 }
10859
10860 if (benchmark)
10861 {
10862 hash_info->orighash = (char *) mymalloc (256);
10863 }
10864 }
10865 }
10866
10867 if (isSalted)
10868 {
10869 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10870
10871 if (esalt_size)
10872 {
10873 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10874 }
10875 }
10876 else
10877 {
10878 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10879 }
10880
10881 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10882 {
10883 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10884
10885 if (isSalted)
10886 {
10887 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10888
10889 if (esalt_size)
10890 {
10891 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10892 }
10893 }
10894 else
10895 {
10896 hashes_buf[hash_pos].salt = &salts_buf[0];
10897 }
10898 }
10899
10900 /**
10901 * load hashes, part III: parse hashes or generate them if benchmark
10902 */
10903
10904 uint hashes_cnt = 0;
10905
10906 if (benchmark == 0)
10907 {
10908 if (keyspace == 1)
10909 {
10910 // useless to read hash file for keyspace, cheat a little bit w/ optind
10911 }
10912 else if (hashes_avail == 0)
10913 {
10914 }
10915 else if (hashlist_mode == HL_MODE_ARG)
10916 {
10917 char *input_buf = myargv[optind];
10918
10919 uint input_len = strlen (input_buf);
10920
10921 logfile_top_var_string ("target", input_buf);
10922
10923 char *hash_buf = NULL;
10924 int hash_len = 0;
10925
10926 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10927
10928 bool hash_fmt_error = 0;
10929
10930 if (hash_len < 1) hash_fmt_error = 1;
10931 if (hash_buf == NULL) hash_fmt_error = 1;
10932
10933 if (hash_fmt_error)
10934 {
10935 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
10936 }
10937 else
10938 {
10939 if (opts_type & OPTS_TYPE_HASH_COPY)
10940 {
10941 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10942
10943 hash_info_tmp->orighash = mystrdup (hash_buf);
10944 }
10945
10946 if (isSalted)
10947 {
10948 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10949 }
10950
10951 int parser_status = PARSER_OK;
10952
10953 if (hash_mode == 2500)
10954 {
10955 if (hash_len == 0)
10956 {
10957 log_error ("ERROR: hccap file not specified");
10958
10959 return (-1);
10960 }
10961
10962 hashlist_mode = HL_MODE_FILE;
10963
10964 data.hashlist_mode = hashlist_mode;
10965
10966 FILE *fp = fopen (hash_buf, "rb");
10967
10968 if (fp == NULL)
10969 {
10970 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10971
10972 return (-1);
10973 }
10974
10975 if (hashes_avail < 1)
10976 {
10977 log_error ("ERROR: hccap file is empty or corrupt");
10978
10979 fclose (fp);
10980
10981 return (-1);
10982 }
10983
10984 uint hccap_size = sizeof (hccap_t);
10985
10986 char *in = (char *) mymalloc (hccap_size);
10987
10988 while (!feof (fp))
10989 {
10990 int n = fread (in, hccap_size, 1, fp);
10991
10992 if (n != 1)
10993 {
10994 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10995
10996 break;
10997 }
10998
10999 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11000
11001 if (parser_status != PARSER_OK)
11002 {
11003 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11004
11005 continue;
11006 }
11007
11008 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11009
11010 if ((show == 1) || (left == 1))
11011 {
11012 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11013
11014 char *salt_ptr = (char *) tmp_salt->salt_buf;
11015
11016 int cur_pos = tmp_salt->salt_len;
11017 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11018
11019 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11020
11021 // do the appending task
11022
11023 snprintf (salt_ptr + cur_pos,
11024 rem_len,
11025 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11026 wpa->orig_mac1[0],
11027 wpa->orig_mac1[1],
11028 wpa->orig_mac1[2],
11029 wpa->orig_mac1[3],
11030 wpa->orig_mac1[4],
11031 wpa->orig_mac1[5],
11032 wpa->orig_mac2[0],
11033 wpa->orig_mac2[1],
11034 wpa->orig_mac2[2],
11035 wpa->orig_mac2[3],
11036 wpa->orig_mac2[4],
11037 wpa->orig_mac2[5]);
11038
11039 // memset () the remaining part of the salt
11040
11041 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11042 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11043
11044 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11045
11046 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11047 }
11048
11049 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);
11050 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);
11051
11052 hashes_cnt++;
11053 }
11054
11055 fclose (fp);
11056
11057 myfree (in);
11058 }
11059 else if (hash_mode == 3000)
11060 {
11061 if (hash_len == 32)
11062 {
11063 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11064
11065 hash_t *lm_hash_left = NULL;
11066
11067 if (parser_status == PARSER_OK)
11068 {
11069 lm_hash_left = &hashes_buf[hashes_cnt];
11070
11071 hashes_cnt++;
11072 }
11073 else
11074 {
11075 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11076 }
11077
11078 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11079
11080 hash_t *lm_hash_right = NULL;
11081
11082 if (parser_status == PARSER_OK)
11083 {
11084 lm_hash_right = &hashes_buf[hashes_cnt];
11085
11086 hashes_cnt++;
11087 }
11088 else
11089 {
11090 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11091 }
11092
11093 // show / left
11094
11095 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11096 {
11097 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);
11098 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);
11099 }
11100 }
11101 else
11102 {
11103 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11104
11105 if (parser_status == PARSER_OK)
11106 {
11107 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11108 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11109 }
11110
11111 if (parser_status == PARSER_OK)
11112 {
11113 hashes_cnt++;
11114 }
11115 else
11116 {
11117 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11118 }
11119 }
11120 }
11121 else
11122 {
11123 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11124
11125 if (parser_status == PARSER_OK)
11126 {
11127 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11128 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11129 }
11130
11131 if (parser_status == PARSER_OK)
11132 {
11133 hashes_cnt++;
11134 }
11135 else
11136 {
11137 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11138 }
11139 }
11140 }
11141 }
11142 else if (hashlist_mode == HL_MODE_FILE)
11143 {
11144 char *hashfile = data.hashfile;
11145
11146 FILE *fp;
11147
11148 if ((fp = fopen (hashfile, "rb")) == NULL)
11149 {
11150 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11151
11152 return (-1);
11153 }
11154
11155 uint line_num = 0;
11156
11157 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11158
11159 while (!feof (fp))
11160 {
11161 line_num++;
11162
11163 int line_len = fgetl (fp, line_buf);
11164
11165 if (line_len == 0) continue;
11166
11167 char *hash_buf = NULL;
11168 int hash_len = 0;
11169
11170 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11171
11172 bool hash_fmt_error = 0;
11173
11174 if (hash_len < 1) hash_fmt_error = 1;
11175 if (hash_buf == NULL) hash_fmt_error = 1;
11176
11177 if (hash_fmt_error)
11178 {
11179 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11180
11181 continue;
11182 }
11183
11184 if (username)
11185 {
11186 char *user_buf = NULL;
11187 int user_len = 0;
11188
11189 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11190
11191 if (remove || show)
11192 {
11193 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11194
11195 *user = (user_t *) mymalloc (sizeof (user_t));
11196
11197 user_t *user_ptr = *user;
11198
11199 if (user_buf != NULL)
11200 {
11201 user_ptr->user_name = mystrdup (user_buf);
11202 }
11203 else
11204 {
11205 user_ptr->user_name = mystrdup ("");
11206 }
11207
11208 user_ptr->user_len = user_len;
11209 }
11210 }
11211
11212 if (opts_type & OPTS_TYPE_HASH_COPY)
11213 {
11214 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11215
11216 hash_info_tmp->orighash = mystrdup (hash_buf);
11217 }
11218
11219 if (isSalted)
11220 {
11221 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11222 }
11223
11224 if (hash_mode == 3000)
11225 {
11226 if (hash_len == 32)
11227 {
11228 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11229
11230 if (parser_status < PARSER_GLOBAL_ZERO)
11231 {
11232 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11233
11234 continue;
11235 }
11236
11237 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11238
11239 hashes_cnt++;
11240
11241 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11242
11243 if (parser_status < PARSER_GLOBAL_ZERO)
11244 {
11245 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11246
11247 continue;
11248 }
11249
11250 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11251
11252 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);
11253
11254 hashes_cnt++;
11255
11256 // show / left
11257
11258 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);
11259 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);
11260 }
11261 else
11262 {
11263 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11264
11265 if (parser_status < PARSER_GLOBAL_ZERO)
11266 {
11267 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11268
11269 continue;
11270 }
11271
11272 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);
11273
11274 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11275 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11276
11277 hashes_cnt++;
11278 }
11279 }
11280 else
11281 {
11282 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11283
11284 if (parser_status < PARSER_GLOBAL_ZERO)
11285 {
11286 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11287
11288 continue;
11289 }
11290
11291 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);
11292
11293 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11294 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11295
11296 hashes_cnt++;
11297 }
11298 }
11299
11300 myfree (line_buf);
11301
11302 fclose (fp);
11303
11304 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11305
11306 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11307 }
11308 }
11309 else
11310 {
11311 if (isSalted)
11312 {
11313 hashes_buf[0].salt->salt_len = 8;
11314
11315 // special salt handling
11316
11317 switch (hash_mode)
11318 {
11319 case 1500: hashes_buf[0].salt->salt_len = 2;
11320 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11321 break;
11322 case 1731: hashes_buf[0].salt->salt_len = 4;
11323 break;
11324 case 2410: hashes_buf[0].salt->salt_len = 4;
11325 break;
11326 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11327 break;
11328 case 3100: hashes_buf[0].salt->salt_len = 1;
11329 break;
11330 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11331 break;
11332 case 5800: hashes_buf[0].salt->salt_len = 16;
11333 break;
11334 case 6800: hashes_buf[0].salt->salt_len = 32;
11335 break;
11336 case 8400: hashes_buf[0].salt->salt_len = 40;
11337 break;
11338 case 8800: hashes_buf[0].salt->salt_len = 16;
11339 break;
11340 case 8900: hashes_buf[0].salt->salt_len = 16;
11341 hashes_buf[0].salt->scrypt_N = 1024;
11342 hashes_buf[0].salt->scrypt_r = 1;
11343 hashes_buf[0].salt->scrypt_p = 1;
11344 break;
11345 case 9100: hashes_buf[0].salt->salt_len = 16;
11346 break;
11347 case 9300: hashes_buf[0].salt->salt_len = 14;
11348 hashes_buf[0].salt->scrypt_N = 16384;
11349 hashes_buf[0].salt->scrypt_r = 1;
11350 hashes_buf[0].salt->scrypt_p = 1;
11351 break;
11352 case 9400: hashes_buf[0].salt->salt_len = 16;
11353 break;
11354 case 9500: hashes_buf[0].salt->salt_len = 16;
11355 break;
11356 case 9600: hashes_buf[0].salt->salt_len = 16;
11357 break;
11358 case 9700: hashes_buf[0].salt->salt_len = 16;
11359 break;
11360 case 9710: hashes_buf[0].salt->salt_len = 16;
11361 break;
11362 case 9720: hashes_buf[0].salt->salt_len = 16;
11363 break;
11364 case 9800: hashes_buf[0].salt->salt_len = 16;
11365 break;
11366 case 9810: hashes_buf[0].salt->salt_len = 16;
11367 break;
11368 case 9820: hashes_buf[0].salt->salt_len = 16;
11369 break;
11370 case 10300: hashes_buf[0].salt->salt_len = 12;
11371 break;
11372 case 11500: hashes_buf[0].salt->salt_len = 4;
11373 break;
11374 case 11600: hashes_buf[0].salt->salt_len = 4;
11375 break;
11376 case 12400: hashes_buf[0].salt->salt_len = 4;
11377 break;
11378 case 12500: hashes_buf[0].salt->salt_len = 8;
11379 break;
11380 case 12600: hashes_buf[0].salt->salt_len = 64;
11381 break;
11382 }
11383
11384 // special esalt handling
11385
11386 switch (hash_mode)
11387 {
11388 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11389 break;
11390 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11391 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11392 break;
11393 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11394 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11395 break;
11396 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11397 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11398 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11399 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11400 break;
11401 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11402 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11403 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11404 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11405 break;
11406 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11407 break;
11408 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11409 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11410 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11411 break;
11412 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11413 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11414 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11415 break;
11416 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11417 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11418 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11419 break;
11420 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11421 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11422 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11423 break;
11424 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11425 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11426 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11427 break;
11428 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11429 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11430 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11431 break;
11432 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11433 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11434 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11435 break;
11436 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11437 break;
11438 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11439 break;
11440 }
11441 }
11442
11443 // set hashfile
11444
11445 switch (hash_mode)
11446 {
11447 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11448 break;
11449 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11450 break;
11451 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11452 break;
11453 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11454 break;
11455 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11456 break;
11457 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11458 break;
11459 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11460 break;
11461 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11462 break;
11463 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11464 break;
11465 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11466 break;
11467 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11468 break;
11469 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11470 break;
11471 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11472 break;
11473 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11474 break;
11475 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11476 break;
11477 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11478 break;
11479 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11480 break;
11481 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11482 break;
11483 }
11484
11485 // set default iterations
11486
11487 switch (hash_mode)
11488 {
11489 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11490 break;
11491 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11492 break;
11493 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11494 break;
11495 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11496 break;
11497 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11498 break;
11499 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11500 break;
11501 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11502 break;
11503 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11504 break;
11505 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11506 break;
11507 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11508 break;
11509 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11510 break;
11511 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11512 break;
11513 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11514 break;
11515 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11516 break;
11517 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11518 break;
11519 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11520 break;
11521 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11522 break;
11523 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11524 break;
11525 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11526 break;
11527 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11528 break;
11529 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11530 break;
11531 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11532 break;
11533 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11534 break;
11535 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11536 break;
11537 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11538 break;
11539 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11540 break;
11541 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11542 break;
11543 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11544 break;
11545 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11546 break;
11547 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11548 break;
11549 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11550 break;
11551 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11552 break;
11553 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11554 break;
11555 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11556 break;
11557 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11558 break;
11559 case 8900: hashes_buf[0].salt->salt_iter = 1;
11560 break;
11561 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11562 break;
11563 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11564 break;
11565 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11566 break;
11567 case 9300: hashes_buf[0].salt->salt_iter = 1;
11568 break;
11569 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11570 break;
11571 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11572 break;
11573 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11574 break;
11575 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11576 break;
11577 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11578 break;
11579 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11580 break;
11581 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11582 break;
11583 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11584 break;
11585 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11586 break;
11587 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11588 break;
11589 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11590 break;
11591 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11592 break;
11593 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11594 break;
11595 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11596 break;
11597 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11598 break;
11599 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11600 break;
11601 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11602 break;
11603 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11604 break;
11605 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11606 break;
11607 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11608 break;
11609 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11610 break;
11611 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11612 break;
11613 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11614 break;
11615 }
11616
11617 hashes_cnt = 1;
11618 }
11619
11620 if (show == 1 || left == 1)
11621 {
11622 for (uint i = 0; i < pot_cnt; i++)
11623 {
11624 pot_t *pot_ptr = &pot[i];
11625
11626 hash_t *hashes_buf = &pot_ptr->hash;
11627
11628 local_free (hashes_buf->digest);
11629
11630 if (isSalted)
11631 {
11632 local_free (hashes_buf->salt);
11633 }
11634 }
11635
11636 local_free (pot);
11637
11638 if (data.quiet == 0) log_info_nn ("");
11639
11640 return (0);
11641 }
11642
11643 if (keyspace == 0)
11644 {
11645 if (hashes_cnt == 0)
11646 {
11647 log_error ("ERROR: No hashes loaded");
11648
11649 return (-1);
11650 }
11651 }
11652
11653 /**
11654 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11655 */
11656
11657 if (data.outfile != NULL)
11658 {
11659 if (data.hashfile != NULL)
11660 {
11661 #ifdef _POSIX
11662 struct stat tmpstat_outfile;
11663 struct stat tmpstat_hashfile;
11664 #endif
11665
11666 #ifdef _WIN
11667 struct stat64 tmpstat_outfile;
11668 struct stat64 tmpstat_hashfile;
11669 #endif
11670
11671 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11672
11673 if (tmp_outfile_fp)
11674 {
11675 #ifdef _POSIX
11676 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11677 #endif
11678
11679 #ifdef _WIN
11680 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11681 #endif
11682
11683 fclose (tmp_outfile_fp);
11684 }
11685
11686 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11687
11688 if (tmp_hashfile_fp)
11689 {
11690 #ifdef _POSIX
11691 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11692 #endif
11693
11694 #ifdef _WIN
11695 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11696 #endif
11697
11698 fclose (tmp_hashfile_fp);
11699 }
11700
11701 if (tmp_outfile_fp && tmp_outfile_fp)
11702 {
11703 tmpstat_outfile.st_mode = 0;
11704 tmpstat_outfile.st_nlink = 0;
11705 tmpstat_outfile.st_uid = 0;
11706 tmpstat_outfile.st_gid = 0;
11707 tmpstat_outfile.st_rdev = 0;
11708 tmpstat_outfile.st_atime = 0;
11709
11710 tmpstat_hashfile.st_mode = 0;
11711 tmpstat_hashfile.st_nlink = 0;
11712 tmpstat_hashfile.st_uid = 0;
11713 tmpstat_hashfile.st_gid = 0;
11714 tmpstat_hashfile.st_rdev = 0;
11715 tmpstat_hashfile.st_atime = 0;
11716
11717 #ifdef _POSIX
11718 tmpstat_outfile.st_blksize = 0;
11719 tmpstat_outfile.st_blocks = 0;
11720
11721 tmpstat_hashfile.st_blksize = 0;
11722 tmpstat_hashfile.st_blocks = 0;
11723 #endif
11724
11725 #ifdef _POSIX
11726 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11727 {
11728 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11729
11730 return (-1);
11731 }
11732 #endif
11733
11734 #ifdef _WIN
11735 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11736 {
11737 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11738
11739 return (-1);
11740 }
11741 #endif
11742 }
11743 }
11744 }
11745
11746 /**
11747 * Remove duplicates
11748 */
11749
11750 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11751
11752 if (isSalted)
11753 {
11754 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11755 }
11756 else
11757 {
11758 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11759 }
11760
11761 uint hashes_cnt_orig = hashes_cnt;
11762
11763 hashes_cnt = 1;
11764
11765 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11766 {
11767 if (isSalted)
11768 {
11769 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11770 {
11771 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11772 }
11773 }
11774 else
11775 {
11776 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11777 }
11778
11779 if (hashes_pos > hashes_cnt)
11780 {
11781 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11782 }
11783
11784 hashes_cnt++;
11785 }
11786
11787 /**
11788 * Potfile removes
11789 */
11790
11791 uint potfile_remove_cracks = 0;
11792
11793 if (potfile_disable == 0)
11794 {
11795 hash_t hash_buf;
11796
11797 hash_buf.digest = mymalloc (dgst_size);
11798 hash_buf.salt = NULL;
11799 hash_buf.esalt = NULL;
11800 hash_buf.hash_info = NULL;
11801 hash_buf.cracked = 0;
11802
11803 if (isSalted)
11804 {
11805 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11806 }
11807
11808 if (esalt_size)
11809 {
11810 hash_buf.esalt = mymalloc (esalt_size);
11811 }
11812
11813 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11814
11815 // no solution for these special hash types (for instane because they use hashfile in output etc)
11816 if ((hash_mode != 5200) &&
11817 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11818 (hash_mode != 9000))
11819 {
11820 FILE *fp = fopen (potfile, "rb");
11821
11822 if (fp != NULL)
11823 {
11824 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11825
11826 // to be safe work with a copy (because of line_len loop, i etc)
11827 // moved up here because it's easier to handle continue case
11828 // it's just 64kb
11829
11830 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11831
11832 while (!feof (fp))
11833 {
11834 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11835
11836 if (ptr == NULL) break;
11837
11838 int line_len = strlen (line_buf);
11839
11840 if (line_len == 0) continue;
11841
11842 int iter = MAX_CUT_TRIES;
11843
11844 for (int i = line_len - 1; i && iter; i--, line_len--)
11845 {
11846 if (line_buf[i] != ':') continue;
11847
11848 if (isSalted)
11849 {
11850 memset (hash_buf.salt, 0, sizeof (salt_t));
11851 }
11852
11853 hash_t *found = NULL;
11854
11855 if (hash_mode == 6800)
11856 {
11857 if (i < 64) // 64 = 16 * uint in salt_buf[]
11858 {
11859 // manipulate salt_buf
11860 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11861
11862 hash_buf.salt->salt_len = i;
11863
11864 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11865 }
11866 }
11867 else if (hash_mode == 2500)
11868 {
11869 if (i < 64) // 64 = 16 * uint in salt_buf[]
11870 {
11871 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11872 // manipulate salt_buf
11873
11874 memcpy (line_buf_cpy, line_buf, i);
11875
11876 char *mac2_pos = strrchr (line_buf_cpy, ':');
11877
11878 if (mac2_pos == NULL) continue;
11879
11880 mac2_pos[0] = 0;
11881 mac2_pos++;
11882
11883 if (strlen (mac2_pos) != 12) continue;
11884
11885 char *mac1_pos = strrchr (line_buf_cpy, ':');
11886
11887 if (mac1_pos == NULL) continue;
11888
11889 mac1_pos[0] = 0;
11890 mac1_pos++;
11891
11892 if (strlen (mac1_pos) != 12) continue;
11893
11894 uint essid_length = mac1_pos - line_buf_cpy - 1;
11895
11896 // here we need the ESSID
11897 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11898
11899 hash_buf.salt->salt_len = essid_length;
11900
11901 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11902
11903 if (found)
11904 {
11905 wpa_t *wpa = (wpa_t *) found->esalt;
11906
11907 // compare hex string(s) vs binary MAC address(es)
11908
11909 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11910 {
11911 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11912 {
11913 found = NULL;
11914
11915 break;
11916 }
11917 }
11918
11919 // early skip ;)
11920 if (!found) continue;
11921
11922 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11923 {
11924 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11925 {
11926 found = NULL;
11927
11928 break;
11929 }
11930 }
11931 }
11932 }
11933 }
11934 else
11935 {
11936 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11937
11938 if (parser_status == PARSER_OK)
11939 {
11940 if (isSalted)
11941 {
11942 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11943 }
11944 else
11945 {
11946 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11947 }
11948 }
11949 }
11950
11951 if (found == NULL) continue;
11952
11953 if (!found->cracked) potfile_remove_cracks++;
11954
11955 found->cracked = 1;
11956
11957 if (found) break;
11958
11959 iter--;
11960 }
11961 }
11962
11963 myfree (line_buf_cpy);
11964
11965 myfree (line_buf);
11966
11967 fclose (fp);
11968 }
11969 }
11970
11971 if (esalt_size)
11972 {
11973 local_free (hash_buf.esalt);
11974 }
11975
11976 if (isSalted)
11977 {
11978 local_free (hash_buf.salt);
11979 }
11980
11981 local_free (hash_buf.digest);
11982 }
11983
11984 /**
11985 * Now generate all the buffers required for later
11986 */
11987
11988 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11989
11990 salt_t *salts_buf_new = NULL;
11991 void *esalts_buf_new = NULL;
11992
11993 if (isSalted)
11994 {
11995 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11996
11997 if (esalt_size)
11998 {
11999 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12000 }
12001 }
12002 else
12003 {
12004 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12005 }
12006
12007 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12008
12009 uint digests_cnt = hashes_cnt;
12010 uint digests_done = 0;
12011
12012 size_t size_digests = digests_cnt * dgst_size;
12013 size_t size_shown = digests_cnt * sizeof (uint);
12014
12015 uint *digests_shown = (uint *) mymalloc (size_shown);
12016 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12017
12018 uint salts_cnt = 0;
12019 uint salts_done = 0;
12020
12021 hashinfo_t **hash_info = NULL;
12022
12023 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12024 {
12025 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12026
12027 if (username && (remove || show))
12028 {
12029 uint user_pos;
12030
12031 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12032 {
12033 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12034
12035 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12036 }
12037 }
12038 }
12039
12040 uint *salts_shown = (uint *) mymalloc (size_shown);
12041
12042 salt_t *salt_buf;
12043
12044 {
12045 // copied from inner loop
12046
12047 salt_buf = &salts_buf_new[salts_cnt];
12048
12049 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12050
12051 if (esalt_size)
12052 {
12053 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12054 }
12055
12056 salt_buf->digests_cnt = 0;
12057 salt_buf->digests_done = 0;
12058 salt_buf->digests_offset = 0;
12059
12060 salts_cnt++;
12061 }
12062
12063 if (hashes_buf[0].cracked == 1)
12064 {
12065 digests_shown[0] = 1;
12066
12067 digests_done++;
12068
12069 salt_buf->digests_done++;
12070 }
12071
12072 salt_buf->digests_cnt++;
12073
12074 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12075
12076 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12077 {
12078 hash_info[0] = hashes_buf[0].hash_info;
12079 }
12080
12081 // copy from inner loop
12082
12083 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12084 {
12085 if (isSalted)
12086 {
12087 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12088 {
12089 salt_buf = &salts_buf_new[salts_cnt];
12090
12091 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12092
12093 if (esalt_size)
12094 {
12095 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12096 }
12097
12098 salt_buf->digests_cnt = 0;
12099 salt_buf->digests_done = 0;
12100 salt_buf->digests_offset = hashes_pos;
12101
12102 salts_cnt++;
12103 }
12104 }
12105
12106 if (hashes_buf[hashes_pos].cracked == 1)
12107 {
12108 digests_shown[hashes_pos] = 1;
12109
12110 digests_done++;
12111
12112 salt_buf->digests_done++;
12113 }
12114
12115 salt_buf->digests_cnt++;
12116
12117 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12118
12119 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12120 {
12121 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12122 }
12123 }
12124
12125 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12126 {
12127 salt_t *salt_buf = &salts_buf_new[salt_pos];
12128
12129 if (salt_buf->digests_done == salt_buf->digests_cnt)
12130 {
12131 salts_shown[salt_pos] = 1;
12132
12133 salts_done++;
12134 }
12135
12136 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12137 }
12138
12139 local_free (digests_buf);
12140 local_free (salts_buf);
12141 local_free (esalts_buf);
12142
12143 digests_buf = digests_buf_new;
12144 salts_buf = salts_buf_new;
12145 esalts_buf = esalts_buf_new;
12146
12147 local_free (hashes_buf);
12148
12149 /**
12150 * special modification not set from parser
12151 */
12152
12153 switch (hash_mode)
12154 {
12155 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12156 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12157 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12158 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12159 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12160 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12161 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12162 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12163 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12164 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12165 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12166 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12167 }
12168
12169 if (truecrypt_keyfiles)
12170 {
12171 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12172
12173 char *keyfiles = strdup (truecrypt_keyfiles);
12174
12175 char *keyfile = strtok (keyfiles, ",");
12176
12177 do
12178 {
12179 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12180
12181 } while ((keyfile = strtok (NULL, ",")) != NULL);
12182
12183 free (keyfiles);
12184 }
12185
12186 data.digests_cnt = digests_cnt;
12187 data.digests_done = digests_done;
12188 data.digests_buf = digests_buf;
12189 data.digests_shown = digests_shown;
12190 data.digests_shown_tmp = digests_shown_tmp;
12191
12192 data.salts_cnt = salts_cnt;
12193 data.salts_done = salts_done;
12194 data.salts_buf = salts_buf;
12195 data.salts_shown = salts_shown;
12196
12197 data.esalts_buf = esalts_buf;
12198 data.hash_info = hash_info;
12199
12200 /**
12201 * Automatic Optimizers
12202 */
12203
12204 if (salts_cnt == 1)
12205 opti_type |= OPTI_TYPE_SINGLE_SALT;
12206
12207 if (digests_cnt == 1)
12208 opti_type |= OPTI_TYPE_SINGLE_HASH;
12209
12210 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12211 opti_type |= OPTI_TYPE_NOT_ITERATED;
12212
12213 if (attack_mode == ATTACK_MODE_BF)
12214 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12215
12216 data.opti_type = opti_type;
12217
12218 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12219 {
12220 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12221 {
12222 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12223 {
12224 if (opts_type & OPTS_TYPE_ST_ADD80)
12225 {
12226 opts_type &= ~OPTS_TYPE_ST_ADD80;
12227 opts_type |= OPTS_TYPE_PT_ADD80;
12228 }
12229
12230 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12231 {
12232 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12233 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12234 }
12235
12236 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12237 {
12238 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12239 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12240 }
12241 }
12242 }
12243 }
12244
12245 /**
12246 * Some algorithm, like descrypt, can benefit from JIT compilation
12247 */
12248
12249 int force_jit_compilation = -1;
12250
12251 if (hash_mode == 8900)
12252 {
12253 force_jit_compilation = 8900;
12254 }
12255 else if (hash_mode == 9300)
12256 {
12257 force_jit_compilation = 8900;
12258 }
12259 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12260 {
12261 force_jit_compilation = 1500;
12262 }
12263
12264 /**
12265 * generate bitmap tables
12266 */
12267
12268 const uint bitmap_shift1 = 5;
12269 const uint bitmap_shift2 = 13;
12270
12271 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12272
12273 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12274 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12275 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12276 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12277 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12278 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12279 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12280 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12281
12282 uint bitmap_bits;
12283 uint bitmap_nums;
12284 uint bitmap_mask;
12285 uint bitmap_size;
12286
12287 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12288 {
12289 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12290
12291 bitmap_nums = 1 << bitmap_bits;
12292
12293 bitmap_mask = bitmap_nums - 1;
12294
12295 bitmap_size = bitmap_nums * sizeof (uint);
12296
12297 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12298
12299 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;
12300 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;
12301
12302 break;
12303 }
12304
12305 bitmap_nums = 1 << bitmap_bits;
12306
12307 bitmap_mask = bitmap_nums - 1;
12308
12309 bitmap_size = bitmap_nums * sizeof (uint);
12310
12311 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);
12312 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);
12313
12314 /**
12315 * prepare quick rule
12316 */
12317
12318 data.rule_buf_l = rule_buf_l;
12319 data.rule_buf_r = rule_buf_r;
12320
12321 int rule_len_l = (int) strlen (rule_buf_l);
12322 int rule_len_r = (int) strlen (rule_buf_r);
12323
12324 data.rule_len_l = rule_len_l;
12325 data.rule_len_r = rule_len_r;
12326
12327 /**
12328 * load rules
12329 */
12330
12331 uint *all_kernel_rules_cnt = NULL;
12332
12333 kernel_rule_t **all_kernel_rules_buf = NULL;
12334
12335 if (rp_files_cnt)
12336 {
12337 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12338
12339 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12340 }
12341
12342 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12343
12344 int rule_len = 0;
12345
12346 for (uint i = 0; i < rp_files_cnt; i++)
12347 {
12348 uint kernel_rules_avail = 0;
12349
12350 uint kernel_rules_cnt = 0;
12351
12352 kernel_rule_t *kernel_rules_buf = NULL;
12353
12354 char *rp_file = rp_files[i];
12355
12356 char in[BLOCK_SIZE] = { 0 };
12357 char out[BLOCK_SIZE] = { 0 };
12358
12359 FILE *fp = NULL;
12360
12361 uint rule_line = 0;
12362
12363 if ((fp = fopen (rp_file, "rb")) == NULL)
12364 {
12365 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12366
12367 return (-1);
12368 }
12369
12370 while (!feof (fp))
12371 {
12372 memset (rule_buf, 0, HCBUFSIZ);
12373
12374 rule_len = fgetl (fp, rule_buf);
12375
12376 rule_line++;
12377
12378 if (rule_len == 0) continue;
12379
12380 if (rule_buf[0] == '#') continue;
12381
12382 if (kernel_rules_avail == kernel_rules_cnt)
12383 {
12384 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12385
12386 kernel_rules_avail += INCR_RULES;
12387 }
12388
12389 memset (in, 0, BLOCK_SIZE);
12390 memset (out, 0, BLOCK_SIZE);
12391
12392 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12393
12394 if (result == -1)
12395 {
12396 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12397
12398 continue;
12399 }
12400
12401 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12402 {
12403 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12404
12405 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12406
12407 continue;
12408 }
12409
12410 /* its so slow
12411 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12412 {
12413 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12414
12415 continue;
12416 }
12417 */
12418
12419 kernel_rules_cnt++;
12420 }
12421
12422 fclose (fp);
12423
12424 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12425
12426 all_kernel_rules_buf[i] = kernel_rules_buf;
12427 }
12428
12429 /**
12430 * merge rules or automatic rule generator
12431 */
12432
12433 uint kernel_rules_cnt = 0;
12434
12435 kernel_rule_t *kernel_rules_buf = NULL;
12436
12437 if (attack_mode == ATTACK_MODE_STRAIGHT)
12438 {
12439 if (rp_files_cnt)
12440 {
12441 kernel_rules_cnt = 1;
12442
12443 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12444
12445 repeats[0] = kernel_rules_cnt;
12446
12447 for (uint i = 0; i < rp_files_cnt; i++)
12448 {
12449 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12450
12451 repeats[i + 1] = kernel_rules_cnt;
12452 }
12453
12454 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12455
12456 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12457
12458 for (uint i = 0; i < kernel_rules_cnt; i++)
12459 {
12460 uint out_pos = 0;
12461
12462 kernel_rule_t *out = &kernel_rules_buf[i];
12463
12464 for (uint j = 0; j < rp_files_cnt; j++)
12465 {
12466 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12467 uint in_pos;
12468
12469 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12470
12471 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12472 {
12473 if (out_pos == RULES_MAX - 1)
12474 {
12475 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12476
12477 break;
12478 }
12479
12480 out->cmds[out_pos] = in->cmds[in_pos];
12481 }
12482 }
12483 }
12484
12485 local_free (repeats);
12486 }
12487 else if (rp_gen)
12488 {
12489 uint kernel_rules_avail = 0;
12490
12491 while (kernel_rules_cnt < rp_gen)
12492 {
12493 if (kernel_rules_avail == kernel_rules_cnt)
12494 {
12495 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12496
12497 kernel_rules_avail += INCR_RULES;
12498 }
12499
12500 memset (rule_buf, 0, HCBUFSIZ);
12501
12502 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12503
12504 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12505
12506 kernel_rules_cnt++;
12507 }
12508 }
12509 }
12510
12511 myfree (rule_buf);
12512
12513 /**
12514 * generate NOP rules
12515 */
12516
12517 if (kernel_rules_cnt == 0)
12518 {
12519 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12520
12521 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12522
12523 kernel_rules_cnt++;
12524 }
12525
12526 data.kernel_rules_cnt = kernel_rules_cnt;
12527 data.kernel_rules_buf = kernel_rules_buf;
12528
12529 /**
12530 * OpenCL platforms: detect
12531 */
12532
12533 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12534 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12535
12536 cl_uint platforms_cnt = 0;
12537 cl_uint platform_devices_cnt = 0;
12538
12539 if (keyspace == 0)
12540 {
12541 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12542
12543 if (platforms_cnt == 0)
12544 {
12545 log_error ("ERROR: No OpenCL compatible platform found");
12546
12547 return (-1);
12548 }
12549
12550 if (opencl_platforms_filter != (uint) -1)
12551 {
12552 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12553
12554 if (opencl_platforms_filter > platform_cnt_mask)
12555 {
12556 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12557
12558 return (-1);
12559 }
12560 }
12561 }
12562
12563 /**
12564 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12565 */
12566
12567 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12568 {
12569 cl_platform_id platform = platforms[platform_id];
12570
12571 char platform_vendor[INFOSZ] = { 0 };
12572
12573 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12574
12575 #ifdef HAVE_HWMON
12576 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12577 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12578 {
12579 // make sure that we do not directly control the fan for NVidia
12580
12581 gpu_temp_retain = 0;
12582
12583 data.gpu_temp_retain = gpu_temp_retain;
12584 }
12585 #endif // HAVE_NVML || HAVE_NVAPI
12586 #endif
12587 }
12588
12589 /**
12590 * OpenCL devices: simply push all devices from all platforms into the same device array
12591 */
12592
12593 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12594
12595 data.devices_param = devices_param;
12596
12597 uint devices_cnt = 0;
12598
12599 uint devices_active = 0;
12600
12601 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12602 {
12603 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12604
12605 cl_platform_id platform = platforms[platform_id];
12606
12607 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12608
12609 char platform_vendor[INFOSZ] = { 0 };
12610
12611 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12612
12613 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
12614 // this causes trouble with vendor id based macros
12615 // we'll assign generic to those without special optimization available
12616
12617 cl_uint vendor_id = 0;
12618
12619 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
12620 {
12621 vendor_id = VENDOR_ID_AMD;
12622 }
12623 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
12624 {
12625 vendor_id = VENDOR_ID_GENERIC;
12626 }
12627 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
12628 {
12629 vendor_id = VENDOR_ID_GENERIC;
12630 }
12631 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
12632 {
12633 vendor_id = VENDOR_ID_GENERIC;
12634 }
12635 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
12636 {
12637 vendor_id = VENDOR_ID_GENERIC;
12638 }
12639 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12640 {
12641 vendor_id = VENDOR_ID_NV;
12642 }
12643 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
12644 {
12645 vendor_id = VENDOR_ID_GENERIC;
12646 }
12647 else
12648 {
12649 vendor_id = VENDOR_ID_GENERIC;
12650 }
12651
12652 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12653 {
12654 size_t param_value_size = 0;
12655
12656 const uint device_id = devices_cnt;
12657
12658 hc_device_param_t *device_param = &data.devices_param[device_id];
12659
12660 device_param->vendor_id = vendor_id;
12661
12662 device_param->device = platform_devices[platform_devices_id];
12663
12664 device_param->device_id = device_id;
12665
12666 device_param->platform_devices_id = platform_devices_id;
12667
12668 // device_type
12669
12670 cl_device_type device_type;
12671
12672 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12673
12674 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12675
12676 device_param->device_type = device_type;
12677
12678 // device_name
12679
12680 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12681
12682 char *device_name = (char *) mymalloc (param_value_size);
12683
12684 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12685
12686 device_param->device_name = device_name;
12687
12688 // tuning db
12689
12690 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12691
12692 // device_version
12693
12694 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12695
12696 char *device_version = (char *) mymalloc (param_value_size);
12697
12698 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12699
12700 device_param->device_version = device_version;
12701
12702 // device_opencl_version
12703
12704 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12705
12706 char *device_opencl_version = (char *) mymalloc (param_value_size);
12707
12708 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12709
12710 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12711
12712 myfree (device_opencl_version);
12713
12714 // vector_width
12715
12716 cl_uint vector_width;
12717
12718 if (opencl_vector_width_chgd == 0)
12719 {
12720 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12721 {
12722 if (opti_type & OPTI_TYPE_USES_BITS_64)
12723 {
12724 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12725 }
12726 else
12727 {
12728 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12729 }
12730 }
12731 else
12732 {
12733 vector_width = (cl_uint) tuningdb_entry->vector_width;
12734 }
12735 }
12736 else
12737 {
12738 vector_width = opencl_vector_width;
12739 }
12740
12741 if (vector_width > 16) vector_width = 16;
12742
12743 device_param->vector_width = vector_width;
12744
12745 // max_compute_units
12746
12747 cl_uint device_processors;
12748
12749 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12750
12751 device_param->device_processors = device_processors;
12752
12753 // device_maxmem_alloc
12754 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
12755
12756 cl_ulong device_maxmem_alloc;
12757
12758 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12759
12760 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
12761
12762 // device_global_mem
12763
12764 cl_ulong device_global_mem;
12765
12766 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12767
12768 device_param->device_global_mem = device_global_mem;
12769
12770 // max_work_group_size
12771
12772 size_t device_maxworkgroup_size;
12773
12774 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
12775
12776 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
12777
12778 // max_clock_frequency
12779
12780 cl_uint device_maxclock_frequency;
12781
12782 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12783
12784 device_param->device_maxclock_frequency = device_maxclock_frequency;
12785
12786 // skipped
12787
12788 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12789 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12790
12791 device_param->skipped = (skipped1 || skipped2);
12792
12793 // driver_version
12794 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12795
12796 char *driver_version = (char *) mymalloc (param_value_size);
12797
12798 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12799
12800 device_param->driver_version = driver_version;
12801
12802 // device_name_chksum
12803
12804 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12805
12806 #if __x86_64__
12807 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);
12808 #else
12809 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);
12810 #endif
12811
12812 uint device_name_digest[4] = { 0 };
12813
12814 md5_64 ((uint *) device_name_chksum, device_name_digest);
12815
12816 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12817
12818 device_param->device_name_chksum = device_name_chksum;
12819
12820 // device_processor_cores
12821
12822 if (device_type & CL_DEVICE_TYPE_CPU)
12823 {
12824 cl_uint device_processor_cores = 1;
12825
12826 device_param->device_processor_cores = device_processor_cores;
12827 }
12828
12829 if (device_type & CL_DEVICE_TYPE_GPU)
12830 {
12831 if (vendor_id == VENDOR_ID_AMD)
12832 {
12833 cl_uint device_processor_cores = 0;
12834
12835 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12836
12837 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12838
12839 device_param->device_processor_cores = device_processor_cores;
12840 }
12841 else if (vendor_id == VENDOR_ID_NV)
12842 {
12843 cl_uint kernel_exec_timeout = 0;
12844
12845 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12846
12847 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12848
12849 device_param->kernel_exec_timeout = kernel_exec_timeout;
12850
12851 cl_uint device_processor_cores = 0;
12852
12853 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12854
12855 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12856
12857 device_param->device_processor_cores = device_processor_cores;
12858
12859 cl_uint sm_minor = 0;
12860 cl_uint sm_major = 0;
12861
12862 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12863 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12864
12865 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12866 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12867
12868 device_param->sm_minor = sm_minor;
12869 device_param->sm_major = sm_major;
12870 }
12871 else
12872 {
12873 cl_uint device_processor_cores = 1;
12874
12875 device_param->device_processor_cores = device_processor_cores;
12876 }
12877 }
12878
12879 // display results
12880
12881 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12882 {
12883 if (device_param->skipped == 0)
12884 {
12885 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12886 device_id + 1,
12887 device_name,
12888 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12889 (unsigned int) (device_global_mem / 1024 / 1024),
12890 (unsigned int) (device_maxclock_frequency),
12891 (unsigned int) device_processors);
12892 }
12893 else
12894 {
12895 log_info ("Device #%u: %s, skipped",
12896 device_id + 1,
12897 device_name);
12898 }
12899 }
12900
12901 // common driver check
12902
12903 if (device_param->skipped == 0)
12904 {
12905 if (device_type & CL_DEVICE_TYPE_GPU)
12906 {
12907 if (vendor_id == VENDOR_ID_AMD)
12908 {
12909 int catalyst_check = (force == 1) ? 0 : 1;
12910
12911 int catalyst_warn = 0;
12912
12913 int catalyst_broken = 0;
12914
12915 if (catalyst_check == 1)
12916 {
12917 catalyst_warn = 1;
12918
12919 // v14.9 and higher
12920 if (atoi (device_param->driver_version) >= 1573)
12921 {
12922 catalyst_warn = 0;
12923 }
12924
12925 catalyst_check = 0;
12926 }
12927
12928 if (catalyst_broken == 1)
12929 {
12930 log_info ("");
12931 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12932 log_info ("It will pass over cracked hashes and does not report them as cracked");
12933 log_info ("You are STRONGLY encouraged not to use it");
12934 log_info ("You can use --force to override this but do not post error reports if you do so");
12935 log_info ("");
12936
12937 return (-1);
12938 }
12939
12940 if (catalyst_warn == 1)
12941 {
12942 log_info ("");
12943 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12944 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12945 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12946 #ifdef _WIN
12947 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12948 #endif
12949 log_info ("You can use --force to override this but do not post error reports if you do so");
12950 log_info ("");
12951
12952 return (-1);
12953 }
12954 }
12955 else if (vendor_id == VENDOR_ID_NV)
12956 {
12957 if (device_param->kernel_exec_timeout != 0)
12958 {
12959 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);
12960 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12961 }
12962 }
12963 }
12964
12965 if (device_type & CL_DEVICE_TYPE_CPU)
12966 {
12967 if (vendor_id == VENDOR_ID_AMD)
12968 {
12969 if (force == 0)
12970 {
12971 log_info ("");
12972 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
12973 log_info ("You are STRONGLY encouraged not to use it");
12974 log_info ("You can use --force to override this but do not post error reports if you do so");
12975 log_info ("A good alternative is the free pocl, but make sure to use a version >= 3.8");
12976 log_info ("");
12977
12978 return (-1);
12979 }
12980 }
12981 }
12982
12983 /**
12984 * kernel accel and loops tuning db adjustment
12985 */
12986
12987 device_param->kernel_accel_min = 1;
12988 device_param->kernel_accel_max = 1024;
12989
12990 device_param->kernel_loops_min = 1;
12991 device_param->kernel_loops_max = 1024;
12992
12993 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12994
12995 if (tuningdb_entry)
12996 {
12997 u32 _kernel_accel = tuningdb_entry->kernel_accel;
12998 u32 _kernel_loops = tuningdb_entry->kernel_loops;
12999
13000 if (_kernel_accel)
13001 {
13002 device_param->kernel_accel_min = _kernel_accel;
13003 device_param->kernel_accel_max = _kernel_accel;
13004 }
13005
13006 if (_kernel_loops)
13007 {
13008 if (workload_profile == 1)
13009 {
13010 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13011 }
13012 else if (workload_profile == 2)
13013 {
13014 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13015 }
13016
13017 device_param->kernel_loops_min = _kernel_loops;
13018 device_param->kernel_loops_max = _kernel_loops;
13019 }
13020 }
13021
13022 // commandline parameters overwrite tuningdb entries
13023
13024 if (kernel_accel)
13025 {
13026 device_param->kernel_accel_min = kernel_accel;
13027 device_param->kernel_accel_max = kernel_accel;
13028 }
13029
13030 if (kernel_loops)
13031 {
13032 device_param->kernel_loops_min = kernel_loops;
13033 device_param->kernel_loops_max = kernel_loops;
13034 }
13035
13036 /**
13037 * activate device
13038 */
13039
13040 devices_active++;
13041 }
13042
13043 // next please
13044
13045 devices_cnt++;
13046 }
13047 }
13048
13049 if (keyspace == 0 && devices_active == 0)
13050 {
13051 log_error ("ERROR: No devices found/left");
13052
13053 return (-1);
13054 }
13055
13056 // additional check to see if the user has chosen a device that is not within the range of available devices (i.e. larger than devices_cnt)
13057
13058 if (devices_filter != (uint) -1)
13059 {
13060 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13061
13062 if (devices_filter > devices_cnt_mask)
13063 {
13064 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13065
13066 return (-1);
13067 }
13068 }
13069
13070 data.devices_cnt = devices_cnt;
13071
13072 data.devices_active = devices_active;
13073
13074 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13075 {
13076 log_info ("");
13077 }
13078
13079 /**
13080 * HM devices: init
13081 */
13082
13083 #ifdef HAVE_HWMON
13084 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13085 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13086 #endif
13087
13088 #ifdef HAVE_ADL
13089 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13090 #endif
13091
13092 if (gpu_temp_disable == 0)
13093 {
13094 #if defined(WIN) && defined(HAVE_NVAPI)
13095 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13096
13097 if (nvapi_init (nvapi) == 0)
13098 data.hm_nv = nvapi;
13099
13100 if (data.hm_nv)
13101 {
13102 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13103 {
13104 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13105
13106 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13107
13108 int tmp_out = 0;
13109
13110 for (int i = 0; i < tmp_in; i++)
13111 {
13112 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13113 }
13114
13115 for (int i = 0; i < tmp_out; i++)
13116 {
13117 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13118
13119 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13120
13121 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;
13122 }
13123 }
13124 }
13125 #endif // WIN && HAVE_NVAPI
13126
13127 #if defined(LINUX) && defined(HAVE_NVML)
13128 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13129
13130 if (nvml_init (nvml) == 0)
13131 data.hm_nv = nvml;
13132
13133 if (data.hm_nv)
13134 {
13135 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13136 {
13137 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13138
13139 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13140
13141 int tmp_out = 0;
13142
13143 for (int i = 0; i < tmp_in; i++)
13144 {
13145 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13146 }
13147
13148 for (int i = 0; i < tmp_out; i++)
13149 {
13150 unsigned int speed;
13151
13152 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;
13153 }
13154 }
13155 }
13156 #endif // LINUX && HAVE_NVML
13157
13158 data.hm_amd = NULL;
13159
13160 #ifdef HAVE_ADL
13161 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13162
13163 if (adl_init (adl) == 0)
13164 data.hm_amd = adl;
13165
13166 if (data.hm_amd)
13167 {
13168 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13169 {
13170 // total number of adapters
13171
13172 int hm_adapters_num;
13173
13174 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13175
13176 // adapter info
13177
13178 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13179
13180 if (lpAdapterInfo == NULL) return (-1);
13181
13182 // get a list (of ids of) valid/usable adapters
13183
13184 int num_adl_adapters = 0;
13185
13186 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13187
13188 if (num_adl_adapters > 0)
13189 {
13190 hc_thread_mutex_lock (mux_adl);
13191
13192 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13193
13194 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13195
13196 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13197 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13198
13199 hc_thread_mutex_unlock (mux_adl);
13200 }
13201
13202 myfree (valid_adl_device_list);
13203 myfree (lpAdapterInfo);
13204 }
13205 }
13206 #endif // HAVE_ADL
13207
13208 if (data.hm_amd == NULL && data.hm_nv == NULL)
13209 {
13210 gpu_temp_disable = 1;
13211 }
13212 }
13213
13214 /**
13215 * OpenCL devices: allocate buffer for device specific information
13216 */
13217
13218 #ifdef HAVE_HWMON
13219 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13220
13221 #ifdef HAVE_ADL
13222 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13223
13224 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13225 #endif // ADL
13226 #endif
13227
13228 /**
13229 * enable custom signal handler(s)
13230 */
13231
13232 if (benchmark == 0)
13233 {
13234 hc_signal (sigHandler_default);
13235 }
13236 else
13237 {
13238 hc_signal (sigHandler_benchmark);
13239 }
13240
13241 /**
13242 * User-defined GPU temp handling
13243 */
13244
13245 #ifdef HAVE_HWMON
13246 if (gpu_temp_disable == 1)
13247 {
13248 gpu_temp_abort = 0;
13249 gpu_temp_retain = 0;
13250 }
13251
13252 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13253 {
13254 if (gpu_temp_abort < gpu_temp_retain)
13255 {
13256 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13257
13258 return (-1);
13259 }
13260 }
13261
13262 data.gpu_temp_disable = gpu_temp_disable;
13263 data.gpu_temp_abort = gpu_temp_abort;
13264 data.gpu_temp_retain = gpu_temp_retain;
13265 #endif
13266
13267 /**
13268 * inform the user
13269 */
13270
13271 if (data.quiet == 0)
13272 {
13273 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13274
13275 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);
13276
13277 if (attack_mode == ATTACK_MODE_STRAIGHT)
13278 {
13279 log_info ("Rules: %u", kernel_rules_cnt);
13280 }
13281
13282 if (opti_type)
13283 {
13284 log_info ("Applicable Optimizers:");
13285
13286 for (uint i = 0; i < 32; i++)
13287 {
13288 const uint opti_bit = 1u << i;
13289
13290 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13291 }
13292 }
13293
13294 /**
13295 * Watchdog and Temperature balance
13296 */
13297
13298 #ifdef HAVE_HWMON
13299 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13300 {
13301 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13302 }
13303
13304 if (gpu_temp_abort == 0)
13305 {
13306 log_info ("Watchdog: Temperature abort trigger disabled");
13307 }
13308 else
13309 {
13310 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13311 }
13312
13313 if (gpu_temp_retain == 0)
13314 {
13315 log_info ("Watchdog: Temperature retain trigger disabled");
13316 }
13317 else
13318 {
13319 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13320 }
13321 #endif
13322 }
13323
13324 if (data.quiet == 0) log_info ("");
13325
13326 /**
13327 * HM devices: copy
13328 */
13329
13330 if (gpu_temp_disable == 0)
13331 {
13332 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13333 {
13334 hc_device_param_t *device_param = &data.devices_param[device_id];
13335
13336 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13337
13338 if (device_param->skipped) continue;
13339
13340 const uint platform_devices_id = device_param->platform_devices_id;
13341
13342 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13343 if (device_param->vendor_id == VENDOR_ID_NV)
13344 {
13345 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13346 }
13347 #endif
13348
13349 #ifdef HAVE_ADL
13350 if (device_param->vendor_id == VENDOR_ID_AMD)
13351 {
13352 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13353 }
13354 #endif
13355 }
13356 }
13357
13358 /*
13359 * Temporary fix:
13360 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13361 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13362 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13363 * Driver / ADL bug?
13364 */
13365
13366 #ifdef HAVE_ADL
13367 if (powertune_enable == 1)
13368 {
13369 hc_thread_mutex_lock (mux_adl);
13370
13371 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13372 {
13373 hc_device_param_t *device_param = &data.devices_param[device_id];
13374
13375 if (device_param->skipped) continue;
13376
13377 if (data.hm_device[device_id].od_version == 6)
13378 {
13379 // set powertune value only
13380
13381 int powertune_supported = 0;
13382
13383 int ADL_rc = 0;
13384
13385 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13386 {
13387 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13388
13389 return (-1);
13390 }
13391
13392 if (powertune_supported != 0)
13393 {
13394 // powertune set
13395 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13396
13397 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13398 {
13399 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13400
13401 return (-1);
13402 }
13403
13404 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13405 {
13406 log_error ("ERROR: Failed to set new ADL PowerControl values");
13407
13408 return (-1);
13409 }
13410 }
13411 }
13412 }
13413
13414 hc_thread_mutex_unlock (mux_adl);
13415 }
13416 #endif // HAVE_ADK
13417 #endif // HAVE_HWMON
13418
13419 #ifdef DEBUG
13420 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13421 #endif
13422
13423 uint kernel_power_all = 0;
13424
13425 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13426 {
13427 /**
13428 * host buffer
13429 */
13430
13431 hc_device_param_t *device_param = &data.devices_param[device_id];
13432
13433 if (device_param->skipped) continue;
13434
13435 /**
13436 * device properties
13437 */
13438
13439 const char *device_name_chksum = device_param->device_name_chksum;
13440 const u32 device_processors = device_param->device_processors;
13441 const u32 device_processor_cores = device_param->device_processor_cores;
13442
13443 /**
13444 * create context for each device
13445 */
13446
13447 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13448
13449 /**
13450 * create command-queue
13451 */
13452
13453 // not supported with NV
13454 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13455
13456 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13457
13458 /**
13459 * kernel threads: some algorithms need a fixed kernel-threads count
13460 * because of shared memory usage or bitslice
13461 * there needs to be some upper limit, otherwise there's too much overhead
13462 */
13463
13464 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
13465
13466 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
13467 {
13468 kernel_threads = KERNEL_THREADS_MAX_CPU;
13469 }
13470
13471 if (hash_mode == 1500) kernel_threads = 64; // DES
13472 if (hash_mode == 3000) kernel_threads = 64; // DES
13473 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
13474 if (hash_mode == 7500) kernel_threads = 64; // RC4
13475 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
13476 if (hash_mode == 9700) kernel_threads = 64; // RC4
13477 if (hash_mode == 9710) kernel_threads = 64; // RC4
13478 if (hash_mode == 9800) kernel_threads = 64; // RC4
13479 if (hash_mode == 9810) kernel_threads = 64; // RC4
13480 if (hash_mode == 10400) kernel_threads = 64; // RC4
13481 if (hash_mode == 10410) kernel_threads = 64; // RC4
13482 if (hash_mode == 10500) kernel_threads = 64; // RC4
13483 if (hash_mode == 13100) kernel_threads = 64; // RC4
13484
13485 /**
13486 * create input buffers on device : calculate size of fixed memory buffers
13487 */
13488
13489 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
13490 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13491
13492 device_param->size_root_css = size_root_css;
13493 device_param->size_markov_css = size_markov_css;
13494
13495 size_t size_results = kernel_threads * sizeof (uint);
13496
13497 device_param->size_results = size_results;
13498
13499 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13500 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13501
13502 size_t size_plains = digests_cnt * sizeof (plain_t);
13503 size_t size_salts = salts_cnt * sizeof (salt_t);
13504 size_t size_esalts = salts_cnt * esalt_size;
13505
13506 device_param->size_plains = size_plains;
13507 device_param->size_digests = size_digests;
13508 device_param->size_shown = size_shown;
13509 device_param->size_salts = size_salts;
13510
13511 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
13512 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
13513 size_t size_tm = 32 * sizeof (bs_word_t);
13514
13515 // scryptV stuff
13516
13517 size_t size_scryptV = 1;
13518
13519 if ((hash_mode == 8900) || (hash_mode == 9300))
13520 {
13521 uint tmto_start = 0;
13522 uint tmto_stop = 10;
13523
13524 if (scrypt_tmto)
13525 {
13526 tmto_start = scrypt_tmto;
13527 }
13528 else
13529 {
13530 // in case the user did not specify the tmto manually
13531 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13532 // but set the lower end only in case the user has a device with too less memory
13533
13534 if (hash_mode == 8900)
13535 {
13536 if (device_param->vendor_id == VENDOR_ID_AMD)
13537 {
13538 tmto_start = 1;
13539 }
13540 else if (device_param->vendor_id == VENDOR_ID_NV)
13541 {
13542 tmto_start = 2;
13543 }
13544 }
13545 else if (hash_mode == 9300)
13546 {
13547 if (device_param->vendor_id == VENDOR_ID_AMD)
13548 {
13549 tmto_start = 2;
13550 }
13551 else if (device_param->vendor_id == VENDOR_ID_NV)
13552 {
13553 tmto_start = 2;
13554 }
13555 }
13556 }
13557
13558 if (quiet == 0) log_info ("");
13559
13560 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13561 {
13562 // TODO: in theory the following calculation needs to be done per salt, not global
13563 // we assume all hashes have the same scrypt settings
13564
13565 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13566
13567 size_scryptV /= 1 << tmto;
13568
13569 size_scryptV *= device_processors * device_processor_cores;
13570
13571 if (size_scryptV > device_param->device_maxmem_alloc)
13572 {
13573 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13574
13575 continue;
13576 }
13577
13578 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13579 {
13580 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13581 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
13582 }
13583
13584 break;
13585 }
13586
13587 if (data.salts_buf[0].scrypt_phy == 0)
13588 {
13589 log_error ("ERROR: can't allocate enough device memory");
13590
13591 return -1;
13592 }
13593
13594 if (quiet == 0) log_info ("");
13595 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13596 }
13597
13598 /**
13599 * some algorithms need a fixed kernel-loops count
13600 */
13601
13602 if (hash_mode == 1500)
13603 {
13604 const u32 kernel_loops_fixed = 1024;
13605
13606 device_param->kernel_loops_min = kernel_loops_fixed;
13607 device_param->kernel_loops_max = kernel_loops_fixed;
13608 }
13609
13610 if (hash_mode == 3000)
13611 {
13612 const u32 kernel_loops_fixed = 1024;
13613
13614 device_param->kernel_loops_min = kernel_loops_fixed;
13615 device_param->kernel_loops_max = kernel_loops_fixed;
13616 }
13617
13618 if (hash_mode == 8900)
13619 {
13620 const u32 kernel_loops_fixed = 1;
13621
13622 device_param->kernel_loops_min = kernel_loops_fixed;
13623 device_param->kernel_loops_max = kernel_loops_fixed;
13624 }
13625
13626 if (hash_mode == 9300)
13627 {
13628 const u32 kernel_loops_fixed = 1;
13629
13630 device_param->kernel_loops_min = kernel_loops_fixed;
13631 device_param->kernel_loops_max = kernel_loops_fixed;
13632 }
13633
13634 if (hash_mode == 12500)
13635 {
13636 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13637
13638 device_param->kernel_loops_min = kernel_loops_fixed;
13639 device_param->kernel_loops_max = kernel_loops_fixed;
13640 }
13641
13642 /**
13643 * some algorithms have a maximum kernel-loops count
13644 */
13645
13646 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13647 {
13648 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13649 {
13650 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13651 }
13652 }
13653
13654 /**
13655 * some algorithms need a special kernel-accel
13656 */
13657
13658 if (hash_mode == 8900)
13659 {
13660 device_param->kernel_accel_min = 1;
13661 device_param->kernel_accel_max = 64;
13662 }
13663
13664 if (hash_mode == 9300)
13665 {
13666 device_param->kernel_accel_min = 1;
13667 device_param->kernel_accel_max = 64;
13668 }
13669
13670 u32 kernel_accel_min = device_param->kernel_accel_min;
13671 u32 kernel_accel_max = device_param->kernel_accel_max;
13672
13673 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13674
13675 size_t size_pws = 4;
13676 size_t size_tmps = 4;
13677 size_t size_hooks = 4;
13678
13679 while (kernel_accel_max >= kernel_accel_min)
13680 {
13681 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13682
13683 // size_pws
13684
13685 size_pws = kernel_power_max * sizeof (pw_t);
13686
13687 // size_tmps
13688
13689 switch (hash_mode)
13690 {
13691 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13692 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13693 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13694 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13695 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13696 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13697 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13698 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13699 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13700 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13701 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13702 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13703 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13704 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13705 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13706 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13707 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13708 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13709 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13710 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13711 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13712 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13713 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13714 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13715 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13716 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13717 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13718 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13719 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13720 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13721 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13722 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13723 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13724 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13725 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13726 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13727 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13728 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13729 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13730 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13731 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13732 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13733 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13734 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13735 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13736 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13737 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13738 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13739 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13740 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13741 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13742 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13743 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13744 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13745 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13746 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13747 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13748 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13749 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13750 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13751 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13752 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13753 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13754 };
13755
13756 // size_hooks
13757
13758 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13759 {
13760 // none yet
13761 }
13762
13763 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13764 // if not, decrease amplifier and try again
13765
13766 int skip = 0;
13767
13768 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13769 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13770 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13771
13772 if (( bitmap_size
13773 + bitmap_size
13774 + bitmap_size
13775 + bitmap_size
13776 + bitmap_size
13777 + bitmap_size
13778 + bitmap_size
13779 + bitmap_size
13780 + size_bfs
13781 + size_combs
13782 + size_digests
13783 + size_esalts
13784 + size_hooks
13785 + size_markov_css
13786 + size_plains
13787 + size_pws
13788 + size_pws // not a bug
13789 + size_results
13790 + size_root_css
13791 + size_rules
13792 + size_rules_c
13793 + size_salts
13794 + size_scryptV
13795 + size_shown
13796 + size_tm
13797 + size_tmps) > device_param->device_global_mem) skip = 1;
13798
13799 if (skip == 1)
13800 {
13801 kernel_accel_max--;
13802
13803 continue;
13804 }
13805
13806 break;
13807 }
13808
13809 /*
13810 if (kernel_accel_max == 0)
13811 {
13812 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13813
13814 return -1;
13815 }
13816 */
13817
13818 device_param->kernel_accel_min = kernel_accel_min;
13819 device_param->kernel_accel_max = kernel_accel_max;
13820
13821 /*
13822 if (kernel_accel_max < kernel_accel)
13823 {
13824 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13825
13826 device_param->kernel_accel = kernel_accel_max;
13827 }
13828 */
13829
13830 device_param->size_bfs = size_bfs;
13831 device_param->size_combs = size_combs;
13832 device_param->size_rules = size_rules;
13833 device_param->size_rules_c = size_rules_c;
13834 device_param->size_pws = size_pws;
13835 device_param->size_tmps = size_tmps;
13836 device_param->size_hooks = size_hooks;
13837
13838 // do not confuse kernel_accel_max with kernel_accel here
13839
13840 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13841
13842 device_param->kernel_threads = kernel_threads;
13843 device_param->kernel_power_user = kernel_power;
13844
13845 kernel_power_all += kernel_power;
13846
13847 /**
13848 * default building options
13849 */
13850
13851 char build_opts[1024] = { 0 };
13852
13853 // we don't have sm_* on vendors not NV but it doesn't matter
13854
13855 snprintf (build_opts, sizeof (build_opts) - 1, "-cl-std=CL1.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);
13856
13857 /**
13858 * main kernel
13859 */
13860
13861 {
13862 /**
13863 * kernel source filename
13864 */
13865
13866 char source_file[256] = { 0 };
13867
13868 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13869
13870 struct stat sst;
13871
13872 if (stat (source_file, &sst) == -1)
13873 {
13874 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13875
13876 return -1;
13877 }
13878
13879 /**
13880 * kernel cached filename
13881 */
13882
13883 char cached_file[256] = { 0 };
13884
13885 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13886
13887 int cached = 1;
13888
13889 struct stat cst;
13890
13891 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13892 {
13893 cached = 0;
13894 }
13895
13896 /**
13897 * kernel compile or load
13898 */
13899
13900 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13901
13902 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13903
13904 if (force_jit_compilation == -1)
13905 {
13906 if (cached == 0)
13907 {
13908 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13909
13910 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13911
13912 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13913
13914 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13915
13916 #ifdef DEBUG
13917 size_t build_log_size = 0;
13918
13919 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13920
13921 if (build_log_size > 1)
13922 {
13923 char *build_log = (char *) malloc (build_log_size + 1);
13924
13925 memset (build_log, 0, build_log_size + 1);
13926
13927 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13928
13929 puts (build_log);
13930
13931 free (build_log);
13932 }
13933 #endif
13934
13935 if (rc != 0)
13936 {
13937 device_param->skipped = true;
13938 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13939 continue;
13940 }
13941
13942 size_t binary_size;
13943
13944 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13945
13946 u8 *binary = (u8 *) mymalloc (binary_size);
13947
13948 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13949
13950 writeProgramBin (cached_file, binary, binary_size);
13951
13952 local_free (binary);
13953 }
13954 else
13955 {
13956 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13957
13958 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13959
13960 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13961
13962 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13963 }
13964 }
13965 else
13966 {
13967 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13968
13969 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13970
13971 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13972
13973 char build_opts_update[1024] = { 0 };
13974
13975 if (force_jit_compilation == 1500)
13976 {
13977 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13978 }
13979 else if (force_jit_compilation == 8900)
13980 {
13981 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);
13982 }
13983 else
13984 {
13985 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
13986 }
13987
13988 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13989
13990 #ifdef DEBUG
13991 size_t build_log_size = 0;
13992
13993 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13994
13995 if (build_log_size > 1)
13996 {
13997 char *build_log = (char *) malloc (build_log_size + 1);
13998
13999 memset (build_log, 0, build_log_size + 1);
14000
14001 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14002
14003 puts (build_log);
14004
14005 free (build_log);
14006 }
14007 #endif
14008
14009 if (rc != 0)
14010 {
14011 device_param->skipped = true;
14012
14013 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14014 }
14015 }
14016
14017 local_free (kernel_lengths);
14018 local_free (kernel_sources[0]);
14019 local_free (kernel_sources);
14020 }
14021
14022 /**
14023 * word generator kernel
14024 */
14025
14026 if (attack_mode != ATTACK_MODE_STRAIGHT)
14027 {
14028 /**
14029 * kernel mp source filename
14030 */
14031
14032 char source_file[256] = { 0 };
14033
14034 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14035
14036 struct stat sst;
14037
14038 if (stat (source_file, &sst) == -1)
14039 {
14040 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14041
14042 return -1;
14043 }
14044
14045 /**
14046 * kernel mp cached filename
14047 */
14048
14049 char cached_file[256] = { 0 };
14050
14051 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14052
14053 int cached = 1;
14054
14055 struct stat cst;
14056
14057 if (stat (cached_file, &cst) == -1)
14058 {
14059 cached = 0;
14060 }
14061
14062 /**
14063 * kernel compile or load
14064 */
14065
14066 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14067
14068 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14069
14070 if (cached == 0)
14071 {
14072 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14073
14074 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14075
14076 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14077
14078 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14079
14080 if (rc != 0)
14081 {
14082 device_param->skipped = true;
14083 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14084 continue;
14085 }
14086
14087 size_t binary_size;
14088
14089 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14090
14091 u8 *binary = (u8 *) mymalloc (binary_size);
14092
14093 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14094
14095 writeProgramBin (cached_file, binary, binary_size);
14096
14097 local_free (binary);
14098 }
14099 else
14100 {
14101 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14102
14103 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14104
14105 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14106
14107 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14108 }
14109
14110 local_free (kernel_lengths);
14111 local_free (kernel_sources[0]);
14112 local_free (kernel_sources);
14113 }
14114
14115 /**
14116 * amplifier kernel
14117 */
14118
14119 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14120 {
14121
14122 }
14123 else
14124 {
14125 /**
14126 * kernel amp source filename
14127 */
14128
14129 char source_file[256] = { 0 };
14130
14131 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14132
14133 struct stat sst;
14134
14135 if (stat (source_file, &sst) == -1)
14136 {
14137 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14138
14139 return -1;
14140 }
14141
14142 /**
14143 * kernel amp cached filename
14144 */
14145
14146 char cached_file[256] = { 0 };
14147
14148 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14149
14150 int cached = 1;
14151
14152 struct stat cst;
14153
14154 if (stat (cached_file, &cst) == -1)
14155 {
14156 cached = 0;
14157 }
14158
14159 /**
14160 * kernel compile or load
14161 */
14162
14163 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14164
14165 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14166
14167 if (cached == 0)
14168 {
14169 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14170
14171 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14172
14173 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14174
14175 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14176
14177 if (rc != 0)
14178 {
14179 device_param->skipped = true;
14180 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14181 continue;
14182 }
14183
14184 size_t binary_size;
14185
14186 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14187
14188 u8 *binary = (u8 *) mymalloc (binary_size);
14189
14190 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14191
14192 writeProgramBin (cached_file, binary, binary_size);
14193
14194 local_free (binary);
14195 }
14196 else
14197 {
14198 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14199
14200 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14201
14202 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14203
14204 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14205 }
14206
14207 local_free (kernel_lengths);
14208 local_free (kernel_sources[0]);
14209 local_free (kernel_sources);
14210 }
14211
14212 // some algorithm collide too fast, make that impossible
14213
14214 if (benchmark == 1)
14215 {
14216 ((uint *) digests_buf)[0] = -1;
14217 ((uint *) digests_buf)[1] = -1;
14218 ((uint *) digests_buf)[2] = -1;
14219 ((uint *) digests_buf)[3] = -1;
14220 }
14221
14222 /**
14223 * global buffers
14224 */
14225
14226 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14227 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14228 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14229 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14230 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14231 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14232 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14233 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14234 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14235 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14236 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14237 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14238 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14239 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14240 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14241 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14242 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14243 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14244
14245 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);
14246 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);
14247 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);
14248 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);
14249 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);
14250 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);
14251 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);
14252 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);
14253 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14254 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14255 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14256
14257 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14258 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14259 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14260 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14261 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14262 run_kernel_bzero (device_param, device_param->d_result, size_results);
14263
14264 /**
14265 * special buffers
14266 */
14267
14268 if (attack_kern == ATTACK_KERN_STRAIGHT)
14269 {
14270 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14271 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14272
14273 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14274
14275 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14276 }
14277 else if (attack_kern == ATTACK_KERN_COMBI)
14278 {
14279 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14280 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14281 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14282 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14283
14284 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14285 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14286 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14287 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14288 }
14289 else if (attack_kern == ATTACK_KERN_BF)
14290 {
14291 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14292 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14293 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14294 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14295 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14296
14297 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14298 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14299 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14300 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14301 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14302 }
14303
14304 if (size_esalts)
14305 {
14306 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14307
14308 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14309 }
14310
14311 /**
14312 * main host data
14313 */
14314
14315 uint *result = (uint *) mymalloc (size_results);
14316
14317 device_param->result = result;
14318
14319 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14320
14321 device_param->pws_buf = pws_buf;
14322
14323 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14324
14325 device_param->combs_buf = combs_buf;
14326
14327 void *hooks_buf = mymalloc (size_hooks);
14328
14329 device_param->hooks_buf = hooks_buf;
14330
14331 /**
14332 * kernel args
14333 */
14334
14335 device_param->kernel_params_buf32[21] = bitmap_mask;
14336 device_param->kernel_params_buf32[22] = bitmap_shift1;
14337 device_param->kernel_params_buf32[23] = bitmap_shift2;
14338 device_param->kernel_params_buf32[24] = 0; // salt_pos
14339 device_param->kernel_params_buf32[25] = 0; // loop_pos
14340 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14341 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14342 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14343 device_param->kernel_params_buf32[29] = 0; // digests_offset
14344 device_param->kernel_params_buf32[30] = 0; // combs_mode
14345 device_param->kernel_params_buf32[31] = 0; // gid_max
14346
14347 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14348 ? &device_param->d_pws_buf
14349 : &device_param->d_pws_amp_buf;
14350 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14351 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14352 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14353 device_param->kernel_params[ 4] = &device_param->d_tmps;
14354 device_param->kernel_params[ 5] = &device_param->d_hooks;
14355 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14356 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14357 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14358 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14359 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14360 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14361 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14362 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14363 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14364 device_param->kernel_params[15] = &device_param->d_digests_buf;
14365 device_param->kernel_params[16] = &device_param->d_digests_shown;
14366 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14367 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14368 device_param->kernel_params[19] = &device_param->d_result;
14369 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14370 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14371 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14372 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14373 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14374 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14375 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14376 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14377 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14378 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14379 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14380 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14381
14382 device_param->kernel_params_mp_buf64[3] = 0;
14383 device_param->kernel_params_mp_buf32[4] = 0;
14384 device_param->kernel_params_mp_buf32[5] = 0;
14385 device_param->kernel_params_mp_buf32[6] = 0;
14386 device_param->kernel_params_mp_buf32[7] = 0;
14387 device_param->kernel_params_mp_buf32[8] = 0;
14388
14389 device_param->kernel_params_mp[0] = NULL;
14390 device_param->kernel_params_mp[1] = NULL;
14391 device_param->kernel_params_mp[2] = NULL;
14392 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14393 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14394 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14395 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14396 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14397 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14398
14399 device_param->kernel_params_mp_l_buf64[3] = 0;
14400 device_param->kernel_params_mp_l_buf32[4] = 0;
14401 device_param->kernel_params_mp_l_buf32[5] = 0;
14402 device_param->kernel_params_mp_l_buf32[6] = 0;
14403 device_param->kernel_params_mp_l_buf32[7] = 0;
14404 device_param->kernel_params_mp_l_buf32[8] = 0;
14405 device_param->kernel_params_mp_l_buf32[9] = 0;
14406
14407 device_param->kernel_params_mp_l[0] = NULL;
14408 device_param->kernel_params_mp_l[1] = NULL;
14409 device_param->kernel_params_mp_l[2] = NULL;
14410 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14411 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14412 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14413 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14414 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14415 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14416 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14417
14418 device_param->kernel_params_mp_r_buf64[3] = 0;
14419 device_param->kernel_params_mp_r_buf32[4] = 0;
14420 device_param->kernel_params_mp_r_buf32[5] = 0;
14421 device_param->kernel_params_mp_r_buf32[6] = 0;
14422 device_param->kernel_params_mp_r_buf32[7] = 0;
14423 device_param->kernel_params_mp_r_buf32[8] = 0;
14424
14425 device_param->kernel_params_mp_r[0] = NULL;
14426 device_param->kernel_params_mp_r[1] = NULL;
14427 device_param->kernel_params_mp_r[2] = NULL;
14428 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14429 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14430 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14431 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14432 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14433 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14434
14435 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14436 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14437
14438 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14439 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14440 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14441 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14442 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14443 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14444 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14445
14446 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14447 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14448
14449 /**
14450 * kernel name
14451 */
14452
14453 char kernel_name[64] = { 0 };
14454
14455 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14456 {
14457 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14458 {
14459 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14460
14461 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14462
14463 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14464
14465 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14466
14467 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14468
14469 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14470 }
14471 else
14472 {
14473 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14474
14475 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14476
14477 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14478
14479 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14480
14481 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14482
14483 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14484 }
14485
14486 if (data.attack_mode == ATTACK_MODE_BF)
14487 {
14488 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14489 {
14490 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14491
14492 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14493 }
14494 }
14495 }
14496 else
14497 {
14498 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14499
14500 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14501
14502 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14503
14504 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14505
14506 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14507
14508 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14509
14510 if (opts_type & OPTS_TYPE_HOOK12)
14511 {
14512 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14513
14514 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14515 }
14516
14517 if (opts_type & OPTS_TYPE_HOOK23)
14518 {
14519 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14520
14521 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14522 }
14523 }
14524
14525 for (uint i = 0; i <= 20; i++)
14526 {
14527 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14528 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14529 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14530
14531 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14532 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14533 }
14534
14535 for (uint i = 21; i <= 31; i++)
14536 {
14537 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14538 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14539 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14540
14541 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14542 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14543 }
14544
14545 if (attack_mode == ATTACK_MODE_BF)
14546 {
14547 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14548 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14549
14550 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14551 {
14552 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14553 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14554 }
14555 }
14556 else if (attack_mode == ATTACK_MODE_HYBRID1)
14557 {
14558 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14559 }
14560 else if (attack_mode == ATTACK_MODE_HYBRID2)
14561 {
14562 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14563 }
14564
14565 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14566 {
14567 // nothing to do
14568 }
14569 else
14570 {
14571 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14572 }
14573
14574 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14575 {
14576 // nothing to do
14577 }
14578 else
14579 {
14580 for (uint i = 0; i < 5; i++)
14581 {
14582 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14583 }
14584
14585 for (uint i = 5; i < 7; i++)
14586 {
14587 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14588 }
14589 }
14590
14591 /**
14592 * Store initial fanspeed if gpu_temp_retain is enabled
14593 */
14594
14595 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14596 int gpu_temp_retain_set = 0;
14597
14598 if (gpu_temp_disable == 0)
14599 {
14600 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14601 {
14602 hc_thread_mutex_lock (mux_adl);
14603
14604 if (data.hm_device[device_id].fan_supported == 1)
14605 {
14606 if (gpu_temp_retain_chgd == 0)
14607 {
14608 uint cur_temp = 0;
14609 uint default_temp = 0;
14610
14611 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);
14612
14613 if (ADL_rc == ADL_OK)
14614 {
14615 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14616
14617 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14618
14619 // special case with multi gpu setups: always use minimum retain
14620
14621 if (gpu_temp_retain_set == 0)
14622 {
14623 gpu_temp_retain = gpu_temp_retain_target;
14624 gpu_temp_retain_set = 1;
14625 }
14626 else
14627 {
14628 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14629 }
14630
14631 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14632 }
14633 }
14634
14635 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14636
14637 temp_retain_fanspeed_value[device_id] = fan_speed;
14638
14639 if (fan_speed == -1)
14640 {
14641 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14642
14643 temp_retain_fanspeed_value[device_id] = 0;
14644 }
14645 }
14646
14647 hc_thread_mutex_unlock (mux_adl);
14648 }
14649 }
14650
14651 /**
14652 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14653 */
14654
14655 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14656 {
14657 hc_thread_mutex_lock (mux_adl);
14658
14659 if (data.hm_device[device_id].od_version == 6)
14660 {
14661 int ADL_rc;
14662
14663 // check powertune capabilities first, if not available then skip device
14664
14665 int powertune_supported = 0;
14666
14667 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14668 {
14669 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14670
14671 return (-1);
14672 }
14673
14674 if (powertune_supported != 0)
14675 {
14676 // powercontrol settings
14677
14678 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14679
14680 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14681 {
14682 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14683 }
14684
14685 if (ADL_rc != ADL_OK)
14686 {
14687 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14688
14689 return (-1);
14690 }
14691
14692 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14693 {
14694 log_error ("ERROR: Failed to set new ADL PowerControl values");
14695
14696 return (-1);
14697 }
14698
14699 // clocks
14700
14701 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14702
14703 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14704
14705 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)
14706 {
14707 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14708
14709 return (-1);
14710 }
14711
14712 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14713
14714 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14715
14716 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14717 {
14718 log_error ("ERROR: Failed to get ADL device capabilities");
14719
14720 return (-1);
14721 }
14722
14723 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14724 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14725
14726 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14727 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14728
14729 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14730 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14731
14732 // warning if profile has too low max values
14733
14734 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14735 {
14736 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14737 }
14738
14739 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14740 {
14741 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14742 }
14743
14744 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14745
14746 performance_state->iNumberOfPerformanceLevels = 2;
14747
14748 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14749 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14750 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14751 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14752
14753 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)
14754 {
14755 log_info ("ERROR: Failed to set ADL performance state");
14756
14757 return (-1);
14758 }
14759
14760 local_free (performance_state);
14761 }
14762 }
14763
14764 hc_thread_mutex_unlock (mux_adl);
14765 }
14766 #endif // HAVE_HWMON && HAVE_ADL
14767 }
14768
14769 data.kernel_power_all = kernel_power_all;
14770
14771 if (data.quiet == 0) log_info ("");
14772
14773 /**
14774 * In benchmark-mode, inform user which algorithm is checked
14775 */
14776
14777 if (benchmark == 1)
14778 {
14779 quiet = 0;
14780
14781 data.quiet = quiet;
14782
14783 char *hash_type = strhashtype (data.hash_mode); // not a bug
14784
14785 log_info ("Hashtype: %s", hash_type);
14786 log_info ("");
14787 }
14788
14789 /**
14790 * keep track of the progress
14791 */
14792
14793 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14794 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14795 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14796
14797 /**
14798 * open filehandles
14799 */
14800
14801 #if _WIN
14802 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14803 {
14804 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14805
14806 return (-1);
14807 }
14808
14809 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14810 {
14811 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14812
14813 return (-1);
14814 }
14815
14816 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14817 {
14818 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14819
14820 return (-1);
14821 }
14822 #endif
14823
14824 /**
14825 * dictionary pad
14826 */
14827
14828 segment_size *= (1024 * 1024);
14829
14830 data.segment_size = segment_size;
14831
14832 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14833
14834 wl_data->buf = (char *) mymalloc (segment_size);
14835 wl_data->avail = segment_size;
14836 wl_data->incr = segment_size;
14837 wl_data->cnt = 0;
14838 wl_data->pos = 0;
14839
14840 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14841
14842 data.wordlist_mode = wordlist_mode;
14843
14844 cs_t *css_buf = NULL;
14845 uint css_cnt = 0;
14846 uint dictcnt = 0;
14847 uint maskcnt = 1;
14848 char **masks = NULL;
14849 char **dictfiles = NULL;
14850
14851 uint mask_from_file = 0;
14852
14853 if (attack_mode == ATTACK_MODE_STRAIGHT)
14854 {
14855 if (wordlist_mode == WL_MODE_FILE)
14856 {
14857 int wls_left = myargc - (optind + 1);
14858
14859 for (int i = 0; i < wls_left; i++)
14860 {
14861 char *l0_filename = myargv[optind + 1 + i];
14862
14863 struct stat l0_stat;
14864
14865 if (stat (l0_filename, &l0_stat) == -1)
14866 {
14867 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14868
14869 return (-1);
14870 }
14871
14872 uint is_dir = S_ISDIR (l0_stat.st_mode);
14873
14874 if (is_dir == 0)
14875 {
14876 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14877
14878 dictcnt++;
14879
14880 dictfiles[dictcnt - 1] = l0_filename;
14881 }
14882 else
14883 {
14884 // do not allow --keyspace w/ a directory
14885
14886 if (keyspace == 1)
14887 {
14888 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14889
14890 return (-1);
14891 }
14892
14893 char **dictionary_files = NULL;
14894
14895 dictionary_files = scan_directory (l0_filename);
14896
14897 if (dictionary_files != NULL)
14898 {
14899 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14900
14901 for (int d = 0; dictionary_files[d] != NULL; d++)
14902 {
14903 char *l1_filename = dictionary_files[d];
14904
14905 struct stat l1_stat;
14906
14907 if (stat (l1_filename, &l1_stat) == -1)
14908 {
14909 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14910
14911 return (-1);
14912 }
14913
14914 if (S_ISREG (l1_stat.st_mode))
14915 {
14916 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14917
14918 dictcnt++;
14919
14920 dictfiles[dictcnt - 1] = strdup (l1_filename);
14921 }
14922 }
14923 }
14924
14925 local_free (dictionary_files);
14926 }
14927 }
14928
14929 if (dictcnt < 1)
14930 {
14931 log_error ("ERROR: No usable dictionary file found.");
14932
14933 return (-1);
14934 }
14935 }
14936 else if (wordlist_mode == WL_MODE_STDIN)
14937 {
14938 dictcnt = 1;
14939 }
14940 }
14941 else if (attack_mode == ATTACK_MODE_COMBI)
14942 {
14943 // display
14944
14945 char *dictfile1 = myargv[optind + 1 + 0];
14946 char *dictfile2 = myargv[optind + 1 + 1];
14947
14948 // find the bigger dictionary and use as base
14949
14950 FILE *fp1 = NULL;
14951 FILE *fp2 = NULL;
14952
14953 struct stat tmp_stat;
14954
14955 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14956 {
14957 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14958
14959 return (-1);
14960 }
14961
14962 if (stat (dictfile1, &tmp_stat) == -1)
14963 {
14964 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14965
14966 fclose (fp1);
14967
14968 return (-1);
14969 }
14970
14971 if (S_ISDIR (tmp_stat.st_mode))
14972 {
14973 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14974
14975 fclose (fp1);
14976
14977 return (-1);
14978 }
14979
14980 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14981 {
14982 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14983
14984 fclose (fp1);
14985
14986 return (-1);
14987 }
14988
14989 if (stat (dictfile2, &tmp_stat) == -1)
14990 {
14991 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14992
14993 fclose (fp1);
14994 fclose (fp2);
14995
14996 return (-1);
14997 }
14998
14999 if (S_ISDIR (tmp_stat.st_mode))
15000 {
15001 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15002
15003 fclose (fp1);
15004 fclose (fp2);
15005
15006 return (-1);
15007 }
15008
15009 data.combs_cnt = 1;
15010
15011 data.quiet = 1;
15012
15013 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15014
15015 data.quiet = quiet;
15016
15017 if (words1_cnt == 0)
15018 {
15019 log_error ("ERROR: %s: empty file", dictfile1);
15020
15021 fclose (fp1);
15022 fclose (fp2);
15023
15024 return (-1);
15025 }
15026
15027 data.combs_cnt = 1;
15028
15029 data.quiet = 1;
15030
15031 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15032
15033 data.quiet = quiet;
15034
15035 if (words2_cnt == 0)
15036 {
15037 log_error ("ERROR: %s: empty file", dictfile2);
15038
15039 fclose (fp1);
15040 fclose (fp2);
15041
15042 return (-1);
15043 }
15044
15045 fclose (fp1);
15046 fclose (fp2);
15047
15048 data.dictfile = dictfile1;
15049 data.dictfile2 = dictfile2;
15050
15051 if (words1_cnt >= words2_cnt)
15052 {
15053 data.combs_cnt = words2_cnt;
15054 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15055
15056 dictfiles = &data.dictfile;
15057
15058 dictcnt = 1;
15059 }
15060 else
15061 {
15062 data.combs_cnt = words1_cnt;
15063 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15064
15065 dictfiles = &data.dictfile2;
15066
15067 dictcnt = 1;
15068
15069 // we also have to switch wordlist related rules!
15070
15071 char *tmpc = data.rule_buf_l;
15072
15073 data.rule_buf_l = data.rule_buf_r;
15074 data.rule_buf_r = tmpc;
15075
15076 int tmpi = data.rule_len_l;
15077
15078 data.rule_len_l = data.rule_len_r;
15079 data.rule_len_r = tmpi;
15080 }
15081 }
15082 else if (attack_mode == ATTACK_MODE_BF)
15083 {
15084 char *mask = NULL;
15085
15086 maskcnt = 0;
15087
15088 if (benchmark == 0)
15089 {
15090 mask = myargv[optind + 1];
15091
15092 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15093
15094 if ((optind + 2) <= myargc)
15095 {
15096 struct stat file_stat;
15097
15098 if (stat (mask, &file_stat) == -1)
15099 {
15100 maskcnt = 1;
15101
15102 masks[maskcnt - 1] = mystrdup (mask);
15103 }
15104 else
15105 {
15106 int wls_left = myargc - (optind + 1);
15107
15108 uint masks_avail = INCR_MASKS;
15109
15110 for (int i = 0; i < wls_left; i++)
15111 {
15112 if (i != 0)
15113 {
15114 mask = myargv[optind + 1 + i];
15115
15116 if (stat (mask, &file_stat) == -1)
15117 {
15118 log_error ("ERROR: %s: %s", mask, strerror (errno));
15119
15120 return (-1);
15121 }
15122 }
15123
15124 uint is_file = S_ISREG (file_stat.st_mode);
15125
15126 if (is_file == 1)
15127 {
15128 FILE *mask_fp;
15129
15130 if ((mask_fp = fopen (mask, "r")) == NULL)
15131 {
15132 log_error ("ERROR: %s: %s", mask, strerror (errno));
15133
15134 return (-1);
15135 }
15136
15137 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15138
15139 while (!feof (mask_fp))
15140 {
15141 memset (line_buf, 0, HCBUFSIZ);
15142
15143 int line_len = fgetl (mask_fp, line_buf);
15144
15145 if (line_len == 0) continue;
15146
15147 if (line_buf[0] == '#') continue;
15148
15149 if (masks_avail == maskcnt)
15150 {
15151 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15152
15153 masks_avail += INCR_MASKS;
15154 }
15155
15156 masks[maskcnt] = mystrdup (line_buf);
15157
15158 maskcnt++;
15159 }
15160
15161 myfree (line_buf);
15162
15163 fclose (mask_fp);
15164 }
15165 else
15166 {
15167 log_error ("ERROR: %s: unsupported file-type", mask);
15168
15169 return (-1);
15170 }
15171 }
15172
15173 mask_from_file = 1;
15174 }
15175 }
15176 else
15177 {
15178 custom_charset_1 = (char *) "?l?d?u";
15179 custom_charset_2 = (char *) "?l?d";
15180 custom_charset_3 = (char *) "?l?d*!$@_";
15181
15182 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15183 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15184 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15185
15186 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15187
15188 wordlist_mode = WL_MODE_MASK;
15189
15190 data.wordlist_mode = wordlist_mode;
15191
15192 increment = 1;
15193
15194 maskcnt = 1;
15195 }
15196 }
15197 else
15198 {
15199 /**
15200 * generate full masks and charsets
15201 */
15202
15203 masks = (char **) mymalloc (sizeof (char *));
15204
15205 switch (hash_mode)
15206 {
15207 case 1731: pw_min = 5;
15208 pw_max = 5;
15209 mask = mystrdup ("?b?b?b?b?b");
15210 break;
15211 case 12500: pw_min = 5;
15212 pw_max = 5;
15213 mask = mystrdup ("?b?b?b?b?b");
15214 break;
15215 default: pw_min = 7;
15216 pw_max = 7;
15217 mask = mystrdup ("?b?b?b?b?b?b?b");
15218 break;
15219 }
15220
15221 maskcnt = 1;
15222
15223 masks[maskcnt - 1] = mystrdup (mask);
15224
15225 wordlist_mode = WL_MODE_MASK;
15226
15227 data.wordlist_mode = wordlist_mode;
15228
15229 increment = 1;
15230 }
15231
15232 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15233
15234 if (increment)
15235 {
15236 if (increment_min > pw_min) pw_min = increment_min;
15237
15238 if (increment_max < pw_max) pw_max = increment_max;
15239 }
15240 }
15241 else if (attack_mode == ATTACK_MODE_HYBRID1)
15242 {
15243 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15244
15245 // display
15246
15247 char *mask = myargv[myargc - 1];
15248
15249 maskcnt = 0;
15250
15251 masks = (char **) mymalloc (1 * sizeof (char *));
15252
15253 // mod
15254
15255 struct stat file_stat;
15256
15257 if (stat (mask, &file_stat) == -1)
15258 {
15259 maskcnt = 1;
15260
15261 masks[maskcnt - 1] = mystrdup (mask);
15262 }
15263 else
15264 {
15265 uint is_file = S_ISREG (file_stat.st_mode);
15266
15267 if (is_file == 1)
15268 {
15269 FILE *mask_fp;
15270
15271 if ((mask_fp = fopen (mask, "r")) == NULL)
15272 {
15273 log_error ("ERROR: %s: %s", mask, strerror (errno));
15274
15275 return (-1);
15276 }
15277
15278 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15279
15280 uint masks_avail = 1;
15281
15282 while (!feof (mask_fp))
15283 {
15284 memset (line_buf, 0, HCBUFSIZ);
15285
15286 int line_len = fgetl (mask_fp, line_buf);
15287
15288 if (line_len == 0) continue;
15289
15290 if (line_buf[0] == '#') continue;
15291
15292 if (masks_avail == maskcnt)
15293 {
15294 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15295
15296 masks_avail += INCR_MASKS;
15297 }
15298
15299 masks[maskcnt] = mystrdup (line_buf);
15300
15301 maskcnt++;
15302 }
15303
15304 myfree (line_buf);
15305
15306 fclose (mask_fp);
15307
15308 mask_from_file = 1;
15309 }
15310 else
15311 {
15312 maskcnt = 1;
15313
15314 masks[maskcnt - 1] = mystrdup (mask);
15315 }
15316 }
15317
15318 // base
15319
15320 int wls_left = myargc - (optind + 2);
15321
15322 for (int i = 0; i < wls_left; i++)
15323 {
15324 char *filename = myargv[optind + 1 + i];
15325
15326 struct stat file_stat;
15327
15328 if (stat (filename, &file_stat) == -1)
15329 {
15330 log_error ("ERROR: %s: %s", filename, strerror (errno));
15331
15332 return (-1);
15333 }
15334
15335 uint is_dir = S_ISDIR (file_stat.st_mode);
15336
15337 if (is_dir == 0)
15338 {
15339 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15340
15341 dictcnt++;
15342
15343 dictfiles[dictcnt - 1] = filename;
15344 }
15345 else
15346 {
15347 // do not allow --keyspace w/ a directory
15348
15349 if (keyspace == 1)
15350 {
15351 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15352
15353 return (-1);
15354 }
15355
15356 char **dictionary_files = NULL;
15357
15358 dictionary_files = scan_directory (filename);
15359
15360 if (dictionary_files != NULL)
15361 {
15362 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15363
15364 for (int d = 0; dictionary_files[d] != NULL; d++)
15365 {
15366 char *l1_filename = dictionary_files[d];
15367
15368 struct stat l1_stat;
15369
15370 if (stat (l1_filename, &l1_stat) == -1)
15371 {
15372 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15373
15374 return (-1);
15375 }
15376
15377 if (S_ISREG (l1_stat.st_mode))
15378 {
15379 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15380
15381 dictcnt++;
15382
15383 dictfiles[dictcnt - 1] = strdup (l1_filename);
15384 }
15385 }
15386 }
15387
15388 local_free (dictionary_files);
15389 }
15390 }
15391
15392 if (dictcnt < 1)
15393 {
15394 log_error ("ERROR: No usable dictionary file found.");
15395
15396 return (-1);
15397 }
15398
15399 if (increment)
15400 {
15401 maskcnt = 0;
15402
15403 uint mask_min = increment_min; // we can't reject smaller masks here
15404 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15405
15406 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15407 {
15408 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15409
15410 if (cur_mask == NULL) break;
15411
15412 masks[maskcnt] = cur_mask;
15413
15414 maskcnt++;
15415
15416 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15417 }
15418 }
15419 }
15420 else if (attack_mode == ATTACK_MODE_HYBRID2)
15421 {
15422 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15423
15424 // display
15425
15426 char *mask = myargv[optind + 1 + 0];
15427
15428 maskcnt = 0;
15429
15430 masks = (char **) mymalloc (1 * sizeof (char *));
15431
15432 // mod
15433
15434 struct stat file_stat;
15435
15436 if (stat (mask, &file_stat) == -1)
15437 {
15438 maskcnt = 1;
15439
15440 masks[maskcnt - 1] = mystrdup (mask);
15441 }
15442 else
15443 {
15444 uint is_file = S_ISREG (file_stat.st_mode);
15445
15446 if (is_file == 1)
15447 {
15448 FILE *mask_fp;
15449
15450 if ((mask_fp = fopen (mask, "r")) == NULL)
15451 {
15452 log_error ("ERROR: %s: %s", mask, strerror (errno));
15453
15454 return (-1);
15455 }
15456
15457 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15458
15459 uint masks_avail = 1;
15460
15461 while (!feof (mask_fp))
15462 {
15463 memset (line_buf, 0, HCBUFSIZ);
15464
15465 int line_len = fgetl (mask_fp, line_buf);
15466
15467 if (line_len == 0) continue;
15468
15469 if (line_buf[0] == '#') continue;
15470
15471 if (masks_avail == maskcnt)
15472 {
15473 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15474
15475 masks_avail += INCR_MASKS;
15476 }
15477
15478 masks[maskcnt] = mystrdup (line_buf);
15479
15480 maskcnt++;
15481 }
15482
15483 myfree (line_buf);
15484
15485 fclose (mask_fp);
15486
15487 mask_from_file = 1;
15488 }
15489 else
15490 {
15491 maskcnt = 1;
15492
15493 masks[maskcnt - 1] = mystrdup (mask);
15494 }
15495 }
15496
15497 // base
15498
15499 int wls_left = myargc - (optind + 2);
15500
15501 for (int i = 0; i < wls_left; i++)
15502 {
15503 char *filename = myargv[optind + 2 + i];
15504
15505 struct stat file_stat;
15506
15507 if (stat (filename, &file_stat) == -1)
15508 {
15509 log_error ("ERROR: %s: %s", filename, strerror (errno));
15510
15511 return (-1);
15512 }
15513
15514 uint is_dir = S_ISDIR (file_stat.st_mode);
15515
15516 if (is_dir == 0)
15517 {
15518 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15519
15520 dictcnt++;
15521
15522 dictfiles[dictcnt - 1] = filename;
15523 }
15524 else
15525 {
15526 // do not allow --keyspace w/ a directory
15527
15528 if (keyspace == 1)
15529 {
15530 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15531
15532 return (-1);
15533 }
15534
15535 char **dictionary_files = NULL;
15536
15537 dictionary_files = scan_directory (filename);
15538
15539 if (dictionary_files != NULL)
15540 {
15541 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15542
15543 for (int d = 0; dictionary_files[d] != NULL; d++)
15544 {
15545 char *l1_filename = dictionary_files[d];
15546
15547 struct stat l1_stat;
15548
15549 if (stat (l1_filename, &l1_stat) == -1)
15550 {
15551 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15552
15553 return (-1);
15554 }
15555
15556 if (S_ISREG (l1_stat.st_mode))
15557 {
15558 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15559
15560 dictcnt++;
15561
15562 dictfiles[dictcnt - 1] = strdup (l1_filename);
15563 }
15564 }
15565 }
15566
15567 local_free (dictionary_files);
15568 }
15569 }
15570
15571 if (dictcnt < 1)
15572 {
15573 log_error ("ERROR: No usable dictionary file found.");
15574
15575 return (-1);
15576 }
15577
15578 if (increment)
15579 {
15580 maskcnt = 0;
15581
15582 uint mask_min = increment_min; // we can't reject smaller masks here
15583 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15584
15585 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15586 {
15587 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15588
15589 if (cur_mask == NULL) break;
15590
15591 masks[maskcnt] = cur_mask;
15592
15593 maskcnt++;
15594
15595 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15596 }
15597 }
15598 }
15599
15600 data.pw_min = pw_min;
15601 data.pw_max = pw_max;
15602
15603 /**
15604 * weak hash check
15605 */
15606
15607 if (weak_hash_threshold >= salts_cnt)
15608 {
15609 hc_device_param_t *device_param = NULL;
15610
15611 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15612 {
15613 device_param = &data.devices_param[device_id];
15614
15615 if (device_param->skipped) continue;
15616
15617 break;
15618 }
15619
15620 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15621
15622 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15623 {
15624 weak_hash_check (device_param, salt_pos);
15625 }
15626 }
15627
15628 // Display hack, guarantee that there is at least one \r before real start
15629
15630 if (data.quiet == 0) log_info_nn ("");
15631
15632 /**
15633 * status and monitor threads
15634 */
15635
15636 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15637
15638 hc_thread_t i_thread = 0;
15639
15640 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15641 {
15642 hc_thread_create (i_thread, thread_keypress, &benchmark);
15643 }
15644
15645 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15646
15647 uint ni_threads_cnt = 0;
15648
15649 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15650
15651 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15652
15653 ni_threads_cnt++;
15654
15655 /**
15656 * Outfile remove
15657 */
15658
15659 if (keyspace == 0)
15660 {
15661 if (outfile_check_timer != 0)
15662 {
15663 if (data.outfile_check_directory != NULL)
15664 {
15665 if ((hash_mode != 5200) &&
15666 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15667 (hash_mode != 9000))
15668 {
15669 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15670
15671 ni_threads_cnt++;
15672 }
15673 else
15674 {
15675 outfile_check_timer = 0;
15676 }
15677 }
15678 else
15679 {
15680 outfile_check_timer = 0;
15681 }
15682 }
15683 }
15684
15685 /**
15686 * Inform the user if we got some hashes remove because of the pot file remove feature
15687 */
15688
15689 if (data.quiet == 0)
15690 {
15691 if (potfile_remove_cracks > 0)
15692 {
15693 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15694 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15695 }
15696 }
15697
15698 data.outfile_check_timer = outfile_check_timer;
15699
15700 /**
15701 * main loop
15702 */
15703
15704 char **induction_dictionaries = NULL;
15705
15706 int induction_dictionaries_cnt = 0;
15707
15708 hcstat_table_t *root_table_buf = NULL;
15709 hcstat_table_t *markov_table_buf = NULL;
15710
15711 uint initial_restore_done = 0;
15712
15713 data.maskcnt = maskcnt;
15714
15715 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15716 {
15717 if (data.devices_status == STATUS_CRACKED) break;
15718
15719 data.devices_status = STATUS_INIT;
15720
15721 if (maskpos > rd->maskpos)
15722 {
15723 rd->dictpos = 0;
15724 }
15725
15726 rd->maskpos = maskpos;
15727 data.maskpos = maskpos;
15728
15729 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15730 {
15731 char *mask = masks[maskpos];
15732
15733 if (mask_from_file == 1)
15734 {
15735 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15736
15737 char *str_ptr;
15738 uint str_pos;
15739
15740 uint mask_offset = 0;
15741
15742 uint separator_cnt;
15743
15744 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15745 {
15746 str_ptr = strstr (mask + mask_offset, ",");
15747
15748 if (str_ptr == NULL) break;
15749
15750 str_pos = str_ptr - mask;
15751
15752 // escaped separator, i.e. "\,"
15753
15754 if (str_pos > 0)
15755 {
15756 if (mask[str_pos - 1] == '\\')
15757 {
15758 separator_cnt --;
15759
15760 mask_offset = str_pos + 1;
15761
15762 continue;
15763 }
15764 }
15765
15766 // reset the offset
15767
15768 mask_offset = 0;
15769
15770 mask[str_pos] = '\0';
15771
15772 switch (separator_cnt)
15773 {
15774 case 0:
15775 mp_reset_usr (mp_usr, 0);
15776
15777 custom_charset_1 = mask;
15778 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15779 break;
15780
15781 case 1:
15782 mp_reset_usr (mp_usr, 1);
15783
15784 custom_charset_2 = mask;
15785 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15786 break;
15787
15788 case 2:
15789 mp_reset_usr (mp_usr, 2);
15790
15791 custom_charset_3 = mask;
15792 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15793 break;
15794
15795 case 3:
15796 mp_reset_usr (mp_usr, 3);
15797
15798 custom_charset_4 = mask;
15799 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15800 break;
15801 }
15802
15803 mask = mask + str_pos + 1;
15804 }
15805 }
15806
15807 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15808 {
15809 if (maskpos > 0)
15810 {
15811 local_free (css_buf);
15812 local_free (data.root_css_buf);
15813 local_free (data.markov_css_buf);
15814
15815 local_free (masks[maskpos - 1]);
15816 }
15817
15818 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15819
15820 data.mask = mask;
15821 data.css_cnt = css_cnt;
15822 data.css_buf = css_buf;
15823
15824 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15825
15826 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15827
15828 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15829 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15830
15831 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15832
15833 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15834
15835 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15836 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15837
15838 data.root_css_buf = root_css_buf;
15839 data.markov_css_buf = markov_css_buf;
15840
15841 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15842
15843 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15844
15845 local_free (root_table_buf);
15846 local_free (markov_table_buf);
15847
15848 // args
15849
15850 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15851 {
15852 hc_device_param_t *device_param = &data.devices_param[device_id];
15853
15854 if (device_param->skipped) continue;
15855
15856 device_param->kernel_params_mp[0] = &device_param->d_combs;
15857 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15858 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15859
15860 device_param->kernel_params_mp_buf64[3] = 0;
15861 device_param->kernel_params_mp_buf32[4] = css_cnt;
15862 device_param->kernel_params_mp_buf32[5] = 0;
15863 device_param->kernel_params_mp_buf32[6] = 0;
15864 device_param->kernel_params_mp_buf32[7] = 0;
15865
15866 if (attack_mode == ATTACK_MODE_HYBRID1)
15867 {
15868 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15869 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15870 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15871 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15872 }
15873 else if (attack_mode == ATTACK_MODE_HYBRID2)
15874 {
15875 device_param->kernel_params_mp_buf32[5] = 0;
15876 device_param->kernel_params_mp_buf32[6] = 0;
15877 device_param->kernel_params_mp_buf32[7] = 0;
15878 }
15879
15880 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]);
15881 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]);
15882 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]);
15883
15884 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);
15885 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);
15886 }
15887 }
15888 else if (attack_mode == ATTACK_MODE_BF)
15889 {
15890 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15891
15892 if (increment)
15893 {
15894 for (uint i = 0; i < dictcnt; i++)
15895 {
15896 local_free (dictfiles[i]);
15897 }
15898
15899 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15900 {
15901 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15902
15903 if (l1_filename == NULL) break;
15904
15905 dictcnt++;
15906
15907 dictfiles[dictcnt - 1] = l1_filename;
15908 }
15909 }
15910 else
15911 {
15912 dictcnt++;
15913
15914 dictfiles[dictcnt - 1] = mask;
15915 }
15916
15917 if (dictcnt == 0)
15918 {
15919 log_error ("ERROR: Mask is too small");
15920
15921 return (-1);
15922 }
15923 }
15924 }
15925
15926 free (induction_dictionaries);
15927
15928 // induction_dictionaries_cnt = 0; // implied
15929
15930 if (attack_mode != ATTACK_MODE_BF)
15931 {
15932 if (keyspace == 0)
15933 {
15934 induction_dictionaries = scan_directory (induction_directory);
15935
15936 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15937 }
15938 }
15939
15940 if (induction_dictionaries_cnt)
15941 {
15942 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15943 }
15944
15945 /**
15946 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15947 */
15948 if (keyspace == 1)
15949 {
15950 if ((maskcnt > 1) || (dictcnt > 1))
15951 {
15952 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15953
15954 return (-1);
15955 }
15956 }
15957
15958 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15959 {
15960 char *subid = logfile_generate_subid ();
15961
15962 data.subid = subid;
15963
15964 logfile_sub_msg ("START");
15965
15966 data.devices_status = STATUS_INIT;
15967
15968 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15969 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15970 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15971
15972 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15973
15974 data.cpt_pos = 0;
15975
15976 data.cpt_start = time (NULL);
15977
15978 data.cpt_total = 0;
15979
15980 if (data.restore == 0)
15981 {
15982 rd->words_cur = skip;
15983
15984 skip = 0;
15985
15986 data.skip = 0;
15987 }
15988
15989 data.ms_paused = 0;
15990
15991 data.words_cur = rd->words_cur;
15992
15993 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15994 {
15995 hc_device_param_t *device_param = &data.devices_param[device_id];
15996
15997 if (device_param->skipped) continue;
15998
15999 device_param->speed_pos = 0;
16000
16001 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16002 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16003
16004 device_param->exec_pos = 0;
16005
16006 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16007
16008 device_param->kernel_power = device_param->kernel_power_user;
16009
16010 device_param->outerloop_pos = 0;
16011 device_param->outerloop_left = 0;
16012 device_param->innerloop_pos = 0;
16013 device_param->innerloop_left = 0;
16014
16015 // some more resets:
16016
16017 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16018
16019 device_param->pws_cnt = 0;
16020
16021 device_param->words_off = 0;
16022 device_param->words_done = 0;
16023 }
16024
16025 data.kernel_power_div = 0;
16026
16027 // figure out some workload
16028
16029 if (attack_mode == ATTACK_MODE_STRAIGHT)
16030 {
16031 if (data.wordlist_mode == WL_MODE_FILE)
16032 {
16033 char *dictfile = NULL;
16034
16035 if (induction_dictionaries_cnt)
16036 {
16037 dictfile = induction_dictionaries[0];
16038 }
16039 else
16040 {
16041 dictfile = dictfiles[dictpos];
16042 }
16043
16044 data.dictfile = dictfile;
16045
16046 logfile_sub_string (dictfile);
16047
16048 for (uint i = 0; i < rp_files_cnt; i++)
16049 {
16050 logfile_sub_var_string ("rulefile", rp_files[i]);
16051 }
16052
16053 FILE *fd2 = fopen (dictfile, "rb");
16054
16055 if (fd2 == NULL)
16056 {
16057 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16058
16059 return (-1);
16060 }
16061
16062 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16063
16064 fclose (fd2);
16065
16066 if (data.words_cnt == 0)
16067 {
16068 if (data.devices_status == STATUS_CRACKED) break;
16069 if (data.devices_status == STATUS_ABORTED) break;
16070
16071 dictpos++;
16072
16073 continue;
16074 }
16075 }
16076 }
16077 else if (attack_mode == ATTACK_MODE_COMBI)
16078 {
16079 char *dictfile = data.dictfile;
16080 char *dictfile2 = data.dictfile2;
16081
16082 logfile_sub_string (dictfile);
16083 logfile_sub_string (dictfile2);
16084
16085 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16086 {
16087 FILE *fd2 = fopen (dictfile, "rb");
16088
16089 if (fd2 == NULL)
16090 {
16091 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16092
16093 return (-1);
16094 }
16095
16096 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16097
16098 fclose (fd2);
16099 }
16100 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16101 {
16102 FILE *fd2 = fopen (dictfile2, "rb");
16103
16104 if (fd2 == NULL)
16105 {
16106 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16107
16108 return (-1);
16109 }
16110
16111 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16112
16113 fclose (fd2);
16114 }
16115
16116 if (data.words_cnt == 0)
16117 {
16118 if (data.devices_status == STATUS_CRACKED) break;
16119 if (data.devices_status == STATUS_ABORTED) break;
16120
16121 dictpos++;
16122
16123 continue;
16124 }
16125 }
16126 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16127 {
16128 char *dictfile = NULL;
16129
16130 if (induction_dictionaries_cnt)
16131 {
16132 dictfile = induction_dictionaries[0];
16133 }
16134 else
16135 {
16136 dictfile = dictfiles[dictpos];
16137 }
16138
16139 data.dictfile = dictfile;
16140
16141 char *mask = data.mask;
16142
16143 logfile_sub_string (dictfile);
16144 logfile_sub_string (mask);
16145
16146 FILE *fd2 = fopen (dictfile, "rb");
16147
16148 if (fd2 == NULL)
16149 {
16150 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16151
16152 return (-1);
16153 }
16154
16155 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16156
16157 fclose (fd2);
16158
16159 if (data.words_cnt == 0)
16160 {
16161 if (data.devices_status == STATUS_CRACKED) break;
16162 if (data.devices_status == STATUS_ABORTED) break;
16163
16164 dictpos++;
16165
16166 continue;
16167 }
16168 }
16169 else if (attack_mode == ATTACK_MODE_BF)
16170 {
16171 local_free (css_buf);
16172 local_free (data.root_css_buf);
16173 local_free (data.markov_css_buf);
16174
16175 char *mask = dictfiles[dictpos];
16176
16177 logfile_sub_string (mask);
16178
16179 // base
16180
16181 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16182
16183 if (opts_type & OPTS_TYPE_PT_UNICODE)
16184 {
16185 uint css_cnt_unicode = css_cnt * 2;
16186
16187 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16188
16189 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16190 {
16191 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16192
16193 css_buf_unicode[j + 1].cs_buf[0] = 0;
16194 css_buf_unicode[j + 1].cs_len = 1;
16195 }
16196
16197 free (css_buf);
16198
16199 css_buf = css_buf_unicode;
16200 css_cnt = css_cnt_unicode;
16201 }
16202
16203 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16204
16205 uint mask_min = pw_min;
16206 uint mask_max = pw_max;
16207
16208 if (opts_type & OPTS_TYPE_PT_UNICODE)
16209 {
16210 mask_min *= 2;
16211 mask_max *= 2;
16212 }
16213
16214 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16215 {
16216 if (css_cnt < mask_min)
16217 {
16218 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16219 }
16220
16221 if (css_cnt > mask_max)
16222 {
16223 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16224 }
16225
16226 // skip to next mask
16227
16228 dictpos++;
16229
16230 rd->dictpos = dictpos;
16231
16232 logfile_sub_msg ("STOP");
16233
16234 continue;
16235 }
16236
16237 uint save_css_cnt = css_cnt;
16238
16239 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16240 {
16241 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16242 {
16243 uint salt_len = (uint) data.salts_buf[0].salt_len;
16244 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16245
16246 uint css_cnt_salt = css_cnt + salt_len;
16247
16248 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16249
16250 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16251
16252 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16253 {
16254 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16255 css_buf_salt[j].cs_len = 1;
16256 }
16257
16258 free (css_buf);
16259
16260 css_buf = css_buf_salt;
16261 css_cnt = css_cnt_salt;
16262 }
16263 }
16264
16265 data.mask = mask;
16266 data.css_cnt = css_cnt;
16267 data.css_buf = css_buf;
16268
16269 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16270
16271 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16272
16273 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16274
16275 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16276 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16277
16278 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16279
16280 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16281
16282 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16283 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16284
16285 data.root_css_buf = root_css_buf;
16286 data.markov_css_buf = markov_css_buf;
16287
16288 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16289
16290 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16291
16292 local_free (root_table_buf);
16293 local_free (markov_table_buf);
16294
16295 // copy + args
16296
16297 uint css_cnt_l = css_cnt;
16298 uint css_cnt_r;
16299
16300 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16301 {
16302 if (save_css_cnt < 6)
16303 {
16304 css_cnt_r = 1;
16305 }
16306 else if (save_css_cnt == 6)
16307 {
16308 css_cnt_r = 2;
16309 }
16310 else
16311 {
16312 if (opts_type & OPTS_TYPE_PT_UNICODE)
16313 {
16314 if (save_css_cnt == 8 || save_css_cnt == 10)
16315 {
16316 css_cnt_r = 2;
16317 }
16318 else
16319 {
16320 css_cnt_r = 4;
16321 }
16322 }
16323 else
16324 {
16325 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16326 {
16327 css_cnt_r = 3;
16328 }
16329 else
16330 {
16331 css_cnt_r = 4;
16332 }
16333 }
16334 }
16335 }
16336 else
16337 {
16338 css_cnt_r = 1;
16339
16340 /* unfinished code?
16341 int sum = css_buf[css_cnt_r - 1].cs_len;
16342
16343 for (uint i = 1; i < 4 && i < css_cnt; i++)
16344 {
16345 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16346
16347 css_cnt_r++;
16348
16349 sum *= css_buf[css_cnt_r - 1].cs_len;
16350 }
16351 */
16352 }
16353
16354 css_cnt_l -= css_cnt_r;
16355
16356 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16357
16358 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16359 {
16360 hc_device_param_t *device_param = &data.devices_param[device_id];
16361
16362 if (device_param->skipped) continue;
16363
16364 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16365 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16366 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16367
16368 device_param->kernel_params_mp_l_buf64[3] = 0;
16369 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16370 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16371 device_param->kernel_params_mp_l_buf32[6] = 0;
16372 device_param->kernel_params_mp_l_buf32[7] = 0;
16373 device_param->kernel_params_mp_l_buf32[8] = 0;
16374
16375 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16376 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16377 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16378 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16379
16380 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16381 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16382 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16383
16384 device_param->kernel_params_mp_r_buf64[3] = 0;
16385 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16386 device_param->kernel_params_mp_r_buf32[5] = 0;
16387 device_param->kernel_params_mp_r_buf32[6] = 0;
16388 device_param->kernel_params_mp_r_buf32[7] = 0;
16389
16390 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]);
16391 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]);
16392 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]);
16393
16394 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]);
16395 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]);
16396 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]);
16397
16398 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);
16399 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);
16400 }
16401 }
16402
16403 u64 words_base = data.words_cnt;
16404
16405 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16406 {
16407 if (data.kernel_rules_cnt)
16408 {
16409 words_base /= data.kernel_rules_cnt;
16410 }
16411 }
16412 else if (data.attack_kern == ATTACK_KERN_COMBI)
16413 {
16414 if (data.combs_cnt)
16415 {
16416 words_base /= data.combs_cnt;
16417 }
16418 }
16419 else if (data.attack_kern == ATTACK_KERN_BF)
16420 {
16421 if (data.bfs_cnt)
16422 {
16423 words_base /= data.bfs_cnt;
16424 }
16425 }
16426
16427 data.words_base = words_base;
16428
16429 if (keyspace == 1)
16430 {
16431 log_info ("%llu", (unsigned long long int) words_base);
16432
16433 return (0);
16434 }
16435
16436 if (data.words_cur > data.words_base)
16437 {
16438 log_error ("ERROR: restore value greater keyspace");
16439
16440 return (-1);
16441 }
16442
16443 if (data.words_cur)
16444 {
16445 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16446 {
16447 for (uint i = 0; i < data.salts_cnt; i++)
16448 {
16449 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16450 }
16451 }
16452 else if (data.attack_kern == ATTACK_KERN_COMBI)
16453 {
16454 for (uint i = 0; i < data.salts_cnt; i++)
16455 {
16456 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16457 }
16458 }
16459 else if (data.attack_kern == ATTACK_KERN_BF)
16460 {
16461 for (uint i = 0; i < data.salts_cnt; i++)
16462 {
16463 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16464 }
16465 }
16466 }
16467
16468 /*
16469 * Inform user about possible slow speeds
16470 */
16471
16472 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16473 {
16474 if (data.words_base < kernel_power_all)
16475 {
16476 if (quiet == 0)
16477 {
16478 log_info ("");
16479 log_info ("ATTENTION!");
16480 log_info (" The wordlist or mask you are using is too small.");
16481 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16482 log_info (" The cracking speed will drop.");
16483 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16484 log_info ("");
16485 }
16486 }
16487 }
16488
16489 /*
16490 * Update loopback file
16491 */
16492
16493 if (loopback == 1)
16494 {
16495 time_t now;
16496
16497 time (&now);
16498
16499 uint random_num = get_random_num (0, 9999);
16500
16501 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16502
16503 data.loopback_file = loopback_file;
16504 }
16505
16506 /*
16507 * Update dictionary statistic
16508 */
16509
16510 if (keyspace == 0)
16511 {
16512 dictstat_fp = fopen (dictstat, "wb");
16513
16514 if (dictstat_fp)
16515 {
16516 lock_file (dictstat_fp);
16517
16518 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16519
16520 fclose (dictstat_fp);
16521 }
16522 }
16523
16524 data.devices_status = STATUS_RUNNING;
16525
16526 if (initial_restore_done == 0)
16527 {
16528 if (data.restore_disable == 0) cycle_restore ();
16529
16530 initial_restore_done = 1;
16531 }
16532
16533 hc_timer_set (&data.timer_running);
16534
16535 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16536 {
16537 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16538 {
16539 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16540 if (quiet == 0) fflush (stdout);
16541 }
16542 }
16543 else if (wordlist_mode == WL_MODE_STDIN)
16544 {
16545 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16546 if (data.quiet == 0) log_info ("");
16547 }
16548
16549 time_t runtime_start;
16550
16551 time (&runtime_start);
16552
16553 data.runtime_start = runtime_start;
16554
16555 /**
16556 * create cracker threads
16557 */
16558
16559 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16560
16561 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16562 {
16563 hc_device_param_t *device_param = &devices_param[device_id];
16564
16565 if (wordlist_mode == WL_MODE_STDIN)
16566 {
16567 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16568 }
16569 else
16570 {
16571 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16572 }
16573 }
16574
16575 // wait for crack threads to exit
16576
16577 hc_thread_wait (data.devices_cnt, c_threads);
16578
16579 local_free (c_threads);
16580
16581 data.restore = 0;
16582
16583 // finalize task
16584
16585 logfile_sub_var_uint ("status-after-work", data.devices_status);
16586
16587 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16588
16589 if (data.devices_status == STATUS_CRACKED) break;
16590 if (data.devices_status == STATUS_ABORTED) break;
16591
16592 if (data.devices_status == STATUS_BYPASS)
16593 {
16594 data.devices_status = STATUS_RUNNING;
16595 }
16596
16597 if (induction_dictionaries_cnt)
16598 {
16599 unlink (induction_dictionaries[0]);
16600 }
16601
16602 free (induction_dictionaries);
16603
16604 if (attack_mode != ATTACK_MODE_BF)
16605 {
16606 induction_dictionaries = scan_directory (induction_directory);
16607
16608 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16609 }
16610
16611 if (benchmark == 0)
16612 {
16613 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16614 {
16615 if (quiet == 0) clear_prompt ();
16616
16617 if (quiet == 0) log_info ("");
16618
16619 if (status == 1)
16620 {
16621 status_display ();
16622 }
16623 else
16624 {
16625 if (quiet == 0) status_display ();
16626 }
16627
16628 if (quiet == 0) log_info ("");
16629 }
16630 }
16631
16632 if (attack_mode == ATTACK_MODE_BF)
16633 {
16634 dictpos++;
16635
16636 rd->dictpos = dictpos;
16637 }
16638 else
16639 {
16640 if (induction_dictionaries_cnt)
16641 {
16642 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16643 }
16644 else
16645 {
16646 dictpos++;
16647
16648 rd->dictpos = dictpos;
16649 }
16650 }
16651
16652 time_t runtime_stop;
16653
16654 time (&runtime_stop);
16655
16656 data.runtime_stop = runtime_stop;
16657
16658 logfile_sub_uint (runtime_start);
16659 logfile_sub_uint (runtime_stop);
16660
16661 logfile_sub_msg ("STOP");
16662
16663 global_free (subid);
16664 }
16665
16666 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16667
16668 if (data.devices_status == STATUS_CRACKED) break;
16669 if (data.devices_status == STATUS_ABORTED) break;
16670 if (data.devices_status == STATUS_QUIT) break;
16671
16672 if (data.devices_status == STATUS_BYPASS)
16673 {
16674 data.devices_status = STATUS_RUNNING;
16675 }
16676 }
16677
16678 // 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
16679
16680 if (attack_mode == ATTACK_MODE_STRAIGHT)
16681 {
16682 if (data.wordlist_mode == WL_MODE_FILE)
16683 {
16684 if (data.dictfile == NULL)
16685 {
16686 if (dictfiles != NULL)
16687 {
16688 data.dictfile = dictfiles[0];
16689
16690 hc_timer_set (&data.timer_running);
16691 }
16692 }
16693 }
16694 }
16695 // NOTE: combi is okay because it is already set beforehand
16696 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16697 {
16698 if (data.dictfile == NULL)
16699 {
16700 if (dictfiles != NULL)
16701 {
16702 hc_timer_set (&data.timer_running);
16703
16704 data.dictfile = dictfiles[0];
16705 }
16706 }
16707 }
16708 else if (attack_mode == ATTACK_MODE_BF)
16709 {
16710 if (data.mask == NULL)
16711 {
16712 hc_timer_set (&data.timer_running);
16713
16714 data.mask = masks[0];
16715 }
16716 }
16717
16718 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16719 {
16720 data.devices_status = STATUS_EXHAUSTED;
16721 }
16722
16723 // if cracked / aborted remove last induction dictionary
16724
16725 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16726 {
16727 struct stat induct_stat;
16728
16729 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16730 {
16731 unlink (induction_dictionaries[file_pos]);
16732 }
16733 }
16734
16735 // wait for non-interactive threads
16736
16737 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16738 {
16739 hc_thread_wait (1, &ni_threads[thread_idx]);
16740 }
16741
16742 local_free (ni_threads);
16743
16744 // wait for interactive threads
16745
16746 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16747 {
16748 hc_thread_wait (1, &i_thread);
16749 }
16750
16751 // we dont need restore file anymore
16752 if (data.restore_disable == 0)
16753 {
16754 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16755 {
16756 unlink (eff_restore_file);
16757 unlink (new_restore_file);
16758 }
16759 else
16760 {
16761 cycle_restore ();
16762 }
16763 }
16764
16765 // finally save left hashes
16766
16767 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16768 {
16769 save_hash ();
16770 }
16771
16772 /**
16773 * Clean up
16774 */
16775
16776 if (benchmark == 1)
16777 {
16778 status_benchmark ();
16779
16780 log_info ("");
16781 }
16782 else
16783 {
16784 if (quiet == 0) clear_prompt ();
16785
16786 if (quiet == 0) log_info ("");
16787
16788 if (status == 1)
16789 {
16790 status_display ();
16791 }
16792 else
16793 {
16794 if (quiet == 0) status_display ();
16795 }
16796
16797 if (quiet == 0) log_info ("");
16798 }
16799
16800 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16801 {
16802 hc_device_param_t *device_param = &data.devices_param[device_id];
16803
16804 if (device_param->skipped) continue;
16805
16806 local_free (device_param->result);
16807
16808 local_free (device_param->combs_buf);
16809
16810 local_free (device_param->hooks_buf);
16811
16812 local_free (device_param->device_name);
16813
16814 local_free (device_param->device_name_chksum);
16815
16816 local_free (device_param->device_version);
16817
16818 local_free (device_param->driver_version);
16819
16820 if (device_param->pws_buf) myfree (device_param->pws_buf);
16821 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16822 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16823 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16824 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16825 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16826 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16827 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16828 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16829 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16830 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16831 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16832 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16833 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16834 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16835 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16836 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16837 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16838 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16839 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16840 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16841 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16842 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16843 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16844 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16845 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16846 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16847 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16848 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16849
16850 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16851 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16852 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16853 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16854 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16855 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16856 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16857 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16858 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16859 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16860
16861 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16862 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16863 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16864
16865 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16866 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16867 }
16868
16869 // reset default fan speed
16870
16871 #ifdef HAVE_HWMON
16872 if (gpu_temp_disable == 0)
16873 {
16874 #ifdef HAVE_ADL
16875 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16876 {
16877 hc_thread_mutex_lock (mux_adl);
16878
16879 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16880 {
16881 hc_device_param_t *device_param = &data.devices_param[device_id];
16882
16883 if (device_param->skipped) continue;
16884
16885 if (data.hm_device[device_id].fan_supported == 1)
16886 {
16887 int fanspeed = temp_retain_fanspeed_value[device_id];
16888
16889 if (fanspeed == -1) continue;
16890
16891 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16892
16893 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16894 }
16895 }
16896
16897 hc_thread_mutex_unlock (mux_adl);
16898 }
16899 #endif // HAVE_ADL
16900 }
16901
16902 #ifdef HAVE_ADL
16903 // reset power tuning
16904
16905 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16906 {
16907 hc_thread_mutex_lock (mux_adl);
16908
16909 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16910 {
16911 hc_device_param_t *device_param = &data.devices_param[device_id];
16912
16913 if (device_param->skipped) continue;
16914
16915 if (data.hm_device[device_id].od_version == 6)
16916 {
16917 // check powertune capabilities first, if not available then skip device
16918
16919 int powertune_supported = 0;
16920
16921 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16922 {
16923 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16924
16925 return (-1);
16926 }
16927
16928 if (powertune_supported != 0)
16929 {
16930 // powercontrol settings
16931
16932 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)
16933 {
16934 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16935
16936 return (-1);
16937 }
16938
16939 // clocks
16940
16941 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16942
16943 performance_state->iNumberOfPerformanceLevels = 2;
16944
16945 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16946 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16947 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16948 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16949
16950 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)
16951 {
16952 log_info ("ERROR: Failed to restore ADL performance state");
16953
16954 return (-1);
16955 }
16956
16957 local_free (performance_state);
16958 }
16959 }
16960 }
16961
16962 hc_thread_mutex_unlock (mux_adl);
16963 }
16964 #endif // HAVE_ADL
16965
16966 if (gpu_temp_disable == 0)
16967 {
16968 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16969 if (data.hm_nv)
16970 {
16971 #if defined(LINUX) && defined(HAVE_NVML)
16972
16973 hm_NVML_nvmlShutdown (data.hm_nv);
16974
16975 nvml_close (data.hm_nv);
16976
16977 #elif defined(WIN) && (HAVE_NVAPI)
16978
16979 hm_NvAPI_Unload (data.hm_nv);
16980
16981 nvapi_close (data.hm_nv);
16982
16983 #endif
16984
16985 data.hm_nv = NULL;
16986 }
16987 #endif
16988
16989 #ifdef HAVE_ADL
16990 if (data.hm_amd)
16991 {
16992 hm_ADL_Main_Control_Destroy (data.hm_amd);
16993
16994 adl_close (data.hm_amd);
16995 data.hm_amd = NULL;
16996 }
16997 #endif
16998 }
16999 #endif // HAVE_HWMON
17000
17001 // free memory
17002
17003 local_free (masks);
17004
17005 local_free (dictstat_base);
17006
17007 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17008 {
17009 pot_t *pot_ptr = &pot[pot_pos];
17010
17011 hash_t *hash = &pot_ptr->hash;
17012
17013 local_free (hash->digest);
17014
17015 if (isSalted)
17016 {
17017 local_free (hash->salt);
17018 }
17019 }
17020
17021 local_free (pot);
17022
17023 local_free (all_kernel_rules_cnt);
17024 local_free (all_kernel_rules_buf);
17025
17026 local_free (wl_data->buf);
17027 local_free (wl_data);
17028
17029 local_free (bitmap_s1_a);
17030 local_free (bitmap_s1_b);
17031 local_free (bitmap_s1_c);
17032 local_free (bitmap_s1_d);
17033 local_free (bitmap_s2_a);
17034 local_free (bitmap_s2_b);
17035 local_free (bitmap_s2_c);
17036 local_free (bitmap_s2_d);
17037
17038 #ifdef HAVE_HWMON
17039 local_free (temp_retain_fanspeed_value);
17040 #ifdef HAVE_ADL
17041 local_free (od_clock_mem_status);
17042 local_free (od_power_control_status);
17043 #endif // ADL
17044 #endif
17045
17046 global_free (devices_param);
17047
17048 global_free (kernel_rules_buf);
17049
17050 global_free (root_css_buf);
17051 global_free (markov_css_buf);
17052
17053 global_free (digests_buf);
17054 global_free (digests_shown);
17055 global_free (digests_shown_tmp);
17056
17057 global_free (salts_buf);
17058 global_free (salts_shown);
17059
17060 global_free (esalts_buf);
17061
17062 global_free (words_progress_done);
17063 global_free (words_progress_rejected);
17064 global_free (words_progress_restored);
17065
17066 if (pot_fp) fclose (pot_fp);
17067
17068 if (data.devices_status == STATUS_QUIT) break;
17069 }
17070
17071 // destroy others mutex
17072
17073 hc_thread_mutex_delete (mux_dispatcher);
17074 hc_thread_mutex_delete (mux_counter);
17075 hc_thread_mutex_delete (mux_display);
17076 hc_thread_mutex_delete (mux_adl);
17077
17078 // free memory
17079
17080 local_free (eff_restore_file);
17081 local_free (new_restore_file);
17082
17083 local_free (rd);
17084
17085 // tuning db
17086
17087 tuning_db_destroy (tuning_db);
17088
17089 // loopback
17090
17091 local_free (loopback_file);
17092
17093 if (loopback == 1) unlink (loopback_file);
17094
17095 // induction directory
17096
17097 if (induction_dir == NULL)
17098 {
17099 if (attack_mode != ATTACK_MODE_BF)
17100 {
17101 if (rmdir (induction_directory) == -1)
17102 {
17103 if (errno == ENOENT)
17104 {
17105 // good, we can ignore
17106 }
17107 else if (errno == ENOTEMPTY)
17108 {
17109 // good, we can ignore
17110 }
17111 else
17112 {
17113 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17114
17115 return (-1);
17116 }
17117 }
17118
17119 local_free (induction_directory);
17120 }
17121 }
17122
17123 // outfile-check directory
17124
17125 if (outfile_check_dir == NULL)
17126 {
17127 if (rmdir (outfile_check_directory) == -1)
17128 {
17129 if (errno == ENOENT)
17130 {
17131 // good, we can ignore
17132 }
17133 else if (errno == ENOTEMPTY)
17134 {
17135 // good, we can ignore
17136 }
17137 else
17138 {
17139 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17140
17141 return (-1);
17142 }
17143 }
17144
17145 local_free (outfile_check_directory);
17146 }
17147
17148 time_t proc_stop;
17149
17150 time (&proc_stop);
17151
17152 logfile_top_uint (proc_start);
17153 logfile_top_uint (proc_stop);
17154
17155 logfile_top_msg ("STOP");
17156
17157 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17158 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17159
17160 if (data.ocl) ocl_close (data.ocl);
17161
17162 if (data.devices_status == STATUS_ABORTED) return 2;
17163 if (data.devices_status == STATUS_QUIT) return 2;
17164 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17165 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17166 if (data.devices_status == STATUS_CRACKED) return 0;
17167
17168 return -1;
17169 }
Hashcat additions to support pwdhash