projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
improved autotune engine
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define BENCHMARK_REPEATS 100
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define 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 < 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 = 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 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2525 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2526
2527 const size_t global_work_size[3] = { num_elements, 1, 1 };
2528 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2529
2530 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2531
2532 hc_clFlush (data.ocl, device_param->command_queue);
2533
2534 hc_clFinish (data.ocl, device_param->command_queue);
2535 }
2536
2537 static void run_kernel_tm (hc_device_param_t *device_param)
2538 {
2539 const uint num_elements = 1024; // fixed
2540
2541 uint kernel_threads = 32;
2542
2543 cl_kernel kernel = device_param->kernel_tm;
2544
2545 size_t workgroup_size = 0;
2546 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2547 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2548
2549 const size_t global_work_size[3] = { num_elements, 1, 1 };
2550 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2551
2552 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2553
2554 hc_clFlush (data.ocl, device_param->command_queue);
2555
2556 hc_clFinish (data.ocl, device_param->command_queue);
2557 }
2558
2559 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2560 {
2561 uint num_elements = num;
2562
2563 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2564 device_param->kernel_params_amp_buf32[6] = num_elements;
2565
2566 // causes problems with special threads like in bcrypt
2567 // const uint kernel_threads = device_param->kernel_threads;
2568
2569 uint kernel_threads = KERNEL_THREADS;
2570
2571 while (num_elements % kernel_threads) num_elements++;
2572
2573 cl_kernel kernel = device_param->kernel_amp;
2574
2575 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2576 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2577
2578 size_t workgroup_size = 0;
2579 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2580 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2581
2582 const size_t global_work_size[3] = { num_elements, 1, 1 };
2583 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2584
2585 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2586
2587 hc_clFlush (data.ocl, device_param->command_queue);
2588
2589 hc_clFinish (data.ocl, device_param->command_queue);
2590 }
2591
2592 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2593 {
2594 int rc = -1;
2595
2596 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2597 {
2598 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2599
2600 const cl_uchar zero = 0;
2601
2602 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2603 }
2604
2605 if (rc != 0)
2606 {
2607 // NOTE: clEnqueueFillBuffer () always fails with -59
2608 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2609 // How's that possible, OpenCL 1.2 support is advertised??
2610 // We need to workaround...
2611
2612 #define FILLSZ 0x100000
2613
2614 char *tmp = (char *) mymalloc (FILLSZ);
2615
2616 for (uint i = 0; i < size; i += FILLSZ)
2617 {
2618 const int left = size - i;
2619
2620 const int fillsz = MIN (FILLSZ, left);
2621
2622 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2623 }
2624
2625 myfree (tmp);
2626 }
2627 }
2628
2629 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)
2630 {
2631 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2632 {
2633 if (attack_mode == ATTACK_MODE_BF)
2634 {
2635 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2636 {
2637 const uint size_tm = 32 * sizeof (bs_word_t);
2638
2639 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2640
2641 run_kernel_tm (device_param);
2642
2643 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);
2644 }
2645 }
2646
2647 if (highest_pw_len < 16)
2648 {
2649 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2650 }
2651 else if (highest_pw_len < 32)
2652 {
2653 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2654 }
2655 else
2656 {
2657 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2658 }
2659 }
2660 else
2661 {
2662 run_kernel_amp (device_param, pws_cnt);
2663
2664 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2665
2666 if (opts_type & OPTS_TYPE_HOOK12)
2667 {
2668 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2669 }
2670
2671 uint iter = salt_buf->salt_iter;
2672
2673 uint loop_step = device_param->kernel_loops;
2674
2675 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2676 {
2677 uint loop_left = iter - loop_pos;
2678
2679 loop_left = MIN (loop_left, loop_step);
2680
2681 device_param->kernel_params_buf32[25] = loop_pos;
2682 device_param->kernel_params_buf32[26] = loop_left;
2683
2684 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2685
2686 if (data.devices_status == STATUS_CRACKED) break;
2687 if (data.devices_status == STATUS_ABORTED) break;
2688 if (data.devices_status == STATUS_QUIT) break;
2689
2690 /**
2691 * speed
2692 */
2693
2694 const float iter_part = (float) (loop_pos + loop_left) / iter;
2695
2696 const u64 perf_sum_all = pws_cnt * iter_part;
2697
2698 double speed_ms;
2699
2700 hc_timer_get (device_param->timer_speed, speed_ms);
2701
2702 const u32 speed_pos = device_param->speed_pos;
2703
2704 device_param->speed_cnt[speed_pos] = perf_sum_all;
2705
2706 device_param->speed_ms[speed_pos] = speed_ms;
2707 }
2708
2709 if (opts_type & OPTS_TYPE_HOOK23)
2710 {
2711 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2712
2713 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);
2714
2715 // do something with data
2716
2717 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);
2718 }
2719
2720 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2721 }
2722 }
2723
2724 static int run_rule_engine (const int rule_len, const char *rule_buf)
2725 {
2726 if (rule_len == 0)
2727 {
2728 return 0;
2729 }
2730 else if (rule_len == 1)
2731 {
2732 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2733 }
2734
2735 return 1;
2736 }
2737
2738 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2739 {
2740 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2741 {
2742 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);
2743 }
2744 else if (data.attack_kern == ATTACK_KERN_COMBI)
2745 {
2746 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2747 {
2748 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2749 {
2750 for (u32 i = 0; i < pws_cnt; i++)
2751 {
2752 const u32 pw_len = device_param->pws_buf[i].pw_len;
2753
2754 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2755
2756 ptr[pw_len] = 0x01;
2757 }
2758 }
2759 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2760 {
2761 for (u32 i = 0; i < pws_cnt; i++)
2762 {
2763 const u32 pw_len = device_param->pws_buf[i].pw_len;
2764
2765 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2766
2767 ptr[pw_len] = 0x80;
2768 }
2769 }
2770 }
2771
2772 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);
2773 }
2774 else if (data.attack_kern == ATTACK_KERN_BF)
2775 {
2776 const u64 off = device_param->words_off;
2777
2778 device_param->kernel_params_mp_l_buf64[3] = off;
2779
2780 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2781 }
2782 }
2783
2784 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2785 {
2786 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2787
2788 device_param->kernel_params_buf32[26] = kernel_loops;
2789 device_param->kernel_params_buf32[27] = kernel_loops;
2790
2791 // init some fake words
2792
2793 for (u32 i = 0; i < kernel_power; i++)
2794 {
2795 device_param->pws_buf[i].i[0] = i;
2796 device_param->pws_buf[i].i[1] = 0x01234567;
2797 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2798 }
2799
2800 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);
2801
2802 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2803 {
2804 run_kernel_amp (device_param, kernel_power);
2805 }
2806
2807 // caching run
2808
2809 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2810 {
2811 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2812 }
2813 else
2814 {
2815 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2816 }
2817
2818 // now user repeats
2819
2820 for (int i = 0; i < repeat; i++)
2821 {
2822 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2823 {
2824 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2825 }
2826 else
2827 {
2828 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2829 }
2830 }
2831
2832 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2833
2834 // reset fake words
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 return exec_ms_prev;
2842 }
2843
2844 static void autotune (hc_device_param_t *device_param)
2845 {
2846 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2847
2848 const u32 kernel_accel_min = device_param->kernel_accel_min;
2849 const u32 kernel_accel_max = device_param->kernel_accel_max;
2850
2851 const u32 kernel_loops_min = device_param->kernel_loops_min;
2852 const u32 kernel_loops_max = device_param->kernel_loops_max;
2853
2854 u32 kernel_accel = kernel_accel_min;
2855 u32 kernel_loops = kernel_loops_min;
2856
2857 // steps
2858
2859 #define STEPS_CNT 10
2860
2861 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2862 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2863
2864 u32 steps_accel[STEPS_ACCEL_CNT];
2865 u32 steps_loops[STEPS_LOOPS_CNT];
2866
2867 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2868 {
2869 steps_accel[i] = 1 << i;
2870 }
2871
2872 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2873 {
2874 steps_loops[i] = 1 << i;
2875 }
2876
2877 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2878 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2879
2880 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2881 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2882
2883 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2884 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2885
2886 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2887
2888 u32 kernel_loops_tmp;
2889
2890 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2891 {
2892 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2893
2894 if (exec_ms < target_ms) break;
2895 }
2896
2897 // kernel-accel
2898
2899 if (kernel_accel_min < kernel_accel_max)
2900 {
2901 double e_best = 0;
2902
2903 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2904 {
2905 const u32 kernel_accel_try = steps_accel[i];
2906
2907 if (kernel_accel_try < kernel_accel_min) continue;
2908 if (kernel_accel_try > kernel_accel_max) break;
2909
2910 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2911
2912 if (exec_ms > target_ms) break;
2913
2914 const double e = kernel_accel_try / exec_ms;
2915
2916 if (e > e_best)
2917 {
2918 kernel_accel = kernel_accel_try;
2919
2920 e_best = e;
2921 }
2922 }
2923 }
2924
2925 // kernel-loops final
2926
2927 if (kernel_loops_min < kernel_loops_max)
2928 {
2929 double e_best = 0;
2930
2931 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2932 {
2933 const u32 kernel_loops_try = steps_loops[i];
2934
2935 if (kernel_loops_try < kernel_loops_min) continue;
2936 if (kernel_loops_try > kernel_loops_max) break;
2937
2938 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2939
2940 if (exec_ms > target_ms) break;
2941
2942 const double e = kernel_loops_try / exec_ms;
2943
2944 if (e > e_best)
2945 {
2946 kernel_loops = kernel_loops_try;
2947
2948 e_best = e;
2949 }
2950 }
2951 }
2952
2953 // final balance
2954
2955 u32 kernel_accel_best = kernel_accel;
2956 u32 kernel_loops_best = kernel_loops;
2957
2958 u32 exec_best = -1;
2959
2960 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2961 {
2962 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2963
2964 exec_best = exec_ms;
2965 }
2966
2967 // reset
2968
2969 if (kernel_accel_min < kernel_accel_max)
2970 {
2971 u32 kernel_accel_try = kernel_accel;
2972 u32 kernel_loops_try = kernel_loops;
2973
2974 for (int i = 0; i < 2; i++)
2975 {
2976 kernel_accel_try >>= 1;
2977 kernel_loops_try <<= 1;
2978
2979 if (kernel_accel_try < kernel_accel_min) break;
2980 if (kernel_loops_try > kernel_loops_max) break;
2981
2982 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2983
2984 if (exec_ms < exec_best)
2985 {
2986 kernel_accel_best = kernel_accel_try;
2987 kernel_loops_best = kernel_loops_try;
2988
2989 exec_best = exec_ms;
2990 }
2991 }
2992 }
2993
2994 // reset
2995
2996 if (kernel_loops_min < kernel_loops_max)
2997 {
2998 u32 kernel_accel_try = kernel_accel;
2999 u32 kernel_loops_try = kernel_loops;
3000
3001 for (int i = 0; i < 2; i++)
3002 {
3003 kernel_accel_try <<= 1;
3004 kernel_loops_try >>= 1;
3005
3006 if (kernel_accel_try > kernel_accel_max) break;
3007 if (kernel_loops_try < kernel_loops_min) break;
3008
3009 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3010
3011 if (exec_ms < exec_best)
3012 {
3013 kernel_accel_best = kernel_accel_try;
3014 kernel_loops_best = kernel_loops_try;
3015
3016 exec_best = exec_ms;
3017 }
3018 }
3019 }
3020
3021 // because of the balance we may have some free space left!
3022 // at this point, allow a small variance to overdrive the limit
3023
3024 const int exec_left = (target_ms * 1.2) / exec_best;
3025
3026 const int accel_left = kernel_accel_max / kernel_accel_best;
3027
3028 const int exec_accel_min = MIN (exec_left, accel_left);
3029
3030 if (exec_accel_min)
3031 {
3032 kernel_accel_best *= exec_accel_min;
3033 }
3034
3035 // reset timer
3036
3037 device_param->exec_pos = 0;
3038
3039 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3040
3041 // store
3042
3043 kernel_accel = kernel_accel_best;
3044 kernel_loops = kernel_loops_best;
3045
3046 device_param->kernel_accel = kernel_accel;
3047 device_param->kernel_loops = kernel_loops;
3048
3049 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3050
3051 device_param->kernel_power = kernel_power;
3052
3053 #ifdef DEBUG
3054
3055 if (data.quiet == 0)
3056 {
3057 clear_prompt ();
3058
3059 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3060 "Device #%u: autotuned kernel-loops to %u\n",
3061 device_param->device_id + 1,
3062 kernel_accel,
3063 device_param->device_id + 1,
3064 kernel_loops);
3065
3066 fprintf (stdout, "%s", PROMPT);
3067 fflush (stdout);
3068 }
3069
3070 #endif
3071 }
3072
3073 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3074 {
3075 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3076
3077 // init speed timer
3078
3079 uint speed_pos = device_param->speed_pos;
3080
3081 #ifdef _POSIX
3082 if (device_param->timer_speed.tv_sec == 0)
3083 {
3084 hc_timer_set (&device_param->timer_speed);
3085 }
3086 #endif
3087
3088 #ifdef _WIN
3089 if (device_param->timer_speed.QuadPart == 0)
3090 {
3091 hc_timer_set (&device_param->timer_speed);
3092 }
3093 #endif
3094
3095 // find higest password length, this is for optimization stuff
3096
3097 uint highest_pw_len = 0;
3098
3099 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3100 {
3101 }
3102 else if (data.attack_kern == ATTACK_KERN_COMBI)
3103 {
3104 }
3105 else if (data.attack_kern == ATTACK_KERN_BF)
3106 {
3107 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3108 + device_param->kernel_params_mp_l_buf32[5];
3109 }
3110
3111 // iteration type
3112
3113 uint innerloop_step = 0;
3114 uint innerloop_cnt = 0;
3115
3116 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3117 else innerloop_step = 1;
3118
3119 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3120 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3121 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3122
3123 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3124
3125 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3126 {
3127 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3128
3129 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3130
3131 if (data.devices_status == STATUS_CRACKED) break;
3132 if (data.devices_status == STATUS_ABORTED) break;
3133 if (data.devices_status == STATUS_QUIT) break;
3134 if (data.devices_status == STATUS_BYPASS) break;
3135
3136 salt_t *salt_buf = &data.salts_buf[salt_pos];
3137
3138 device_param->kernel_params_buf32[24] = salt_pos;
3139 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3140 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3141
3142 FILE *combs_fp = device_param->combs_fp;
3143
3144 if (data.attack_mode == ATTACK_MODE_COMBI)
3145 {
3146 rewind (combs_fp);
3147 }
3148
3149 // innerloops
3150
3151 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3152 {
3153 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3154
3155 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3156
3157 if (data.devices_status == STATUS_CRACKED) break;
3158 if (data.devices_status == STATUS_ABORTED) break;
3159 if (data.devices_status == STATUS_QUIT) break;
3160 if (data.devices_status == STATUS_BYPASS) break;
3161
3162 uint innerloop_left = innerloop_cnt - innerloop_pos;
3163
3164 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3165
3166 device_param->innerloop_pos = innerloop_pos;
3167 device_param->innerloop_left = innerloop_left;
3168
3169 device_param->kernel_params_buf32[27] = innerloop_left;
3170
3171 // i think we can get rid of this
3172 if (innerloop_left == 0)
3173 {
3174 puts ("bug, how should this happen????\n");
3175
3176 continue;
3177 }
3178
3179 if (data.salts_shown[salt_pos] == 1)
3180 {
3181 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3182
3183 continue;
3184 }
3185
3186 // initialize amplifiers
3187
3188 if (data.attack_mode == ATTACK_MODE_COMBI)
3189 {
3190 uint i = 0;
3191
3192 while (i < innerloop_left)
3193 {
3194 if (feof (combs_fp)) break;
3195
3196 int line_len = fgetl (combs_fp, line_buf);
3197
3198 if (line_len >= PW_MAX1) continue;
3199
3200 line_len = convert_from_hex (line_buf, line_len);
3201
3202 char *line_buf_new = line_buf;
3203
3204 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3205 {
3206 char rule_buf_out[BLOCK_SIZE] = { 0 };
3207
3208 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3209
3210 if (rule_len_out < 0)
3211 {
3212 data.words_progress_rejected[salt_pos] += pws_cnt;
3213
3214 continue;
3215 }
3216
3217 line_len = rule_len_out;
3218
3219 line_buf_new = rule_buf_out;
3220 }
3221
3222 line_len = MIN (line_len, PW_DICTMAX);
3223
3224 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3225
3226 memcpy (ptr, line_buf_new, line_len);
3227
3228 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3229
3230 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3231 {
3232 uppercase (ptr, line_len);
3233 }
3234
3235 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3236 {
3237 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3238 {
3239 ptr[line_len] = 0x80;
3240 }
3241
3242 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3243 {
3244 ptr[line_len] = 0x01;
3245 }
3246 }
3247
3248 device_param->combs_buf[i].pw_len = line_len;
3249
3250 i++;
3251 }
3252
3253 for (uint j = i; j < innerloop_left; j++)
3254 {
3255 device_param->combs_buf[j].i[0] = 0;
3256 device_param->combs_buf[j].i[1] = 0;
3257 device_param->combs_buf[j].i[2] = 0;
3258 device_param->combs_buf[j].i[3] = 0;
3259 device_param->combs_buf[j].i[4] = 0;
3260 device_param->combs_buf[j].i[5] = 0;
3261 device_param->combs_buf[j].i[6] = 0;
3262 device_param->combs_buf[j].i[7] = 0;
3263
3264 device_param->combs_buf[j].pw_len = 0;
3265 }
3266
3267 innerloop_left = i;
3268 }
3269 else if (data.attack_mode == ATTACK_MODE_BF)
3270 {
3271 u64 off = innerloop_pos;
3272
3273 device_param->kernel_params_mp_r_buf64[3] = off;
3274
3275 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3276 }
3277 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3278 {
3279 u64 off = innerloop_pos;
3280
3281 device_param->kernel_params_mp_buf64[3] = off;
3282
3283 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3284 }
3285 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3286 {
3287 u64 off = innerloop_pos;
3288
3289 device_param->kernel_params_mp_buf64[3] = off;
3290
3291 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3292 }
3293
3294 // copy amplifiers
3295
3296 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3297 {
3298 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);
3299 }
3300 else if (data.attack_mode == ATTACK_MODE_COMBI)
3301 {
3302 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);
3303 }
3304 else if (data.attack_mode == ATTACK_MODE_BF)
3305 {
3306 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);
3307 }
3308 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3309 {
3310 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);
3311 }
3312 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3313 {
3314 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);
3315 }
3316
3317 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3318
3319 if (data.benchmark == 1)
3320 {
3321 double exec_ms_avg_prev = get_avg_exec_time (device_param, EXEC_CACHE);
3322
3323 // a few caching rounds
3324
3325 for (u32 i = 0; i < 2; i++)
3326 {
3327 hc_timer_set (&device_param->timer_speed);
3328
3329 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3330
3331 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
3332
3333 exec_ms_avg_prev = exec_ms_avg;
3334 }
3335
3336 // benchmark_repeats became a maximum possible repeats
3337
3338 for (u32 i = 2; i < data.benchmark_repeats; i++)
3339 {
3340 hc_timer_set (&device_param->timer_speed);
3341
3342 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3343
3344 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
3345
3346 if ((exec_ms_avg_prev / exec_ms_avg) < 1.001) break;
3347
3348 exec_ms_avg_prev = exec_ms_avg;
3349 }
3350 }
3351
3352 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3353
3354 if (data.devices_status == STATUS_CRACKED) break;
3355 if (data.devices_status == STATUS_ABORTED) break;
3356 if (data.devices_status == STATUS_QUIT) break;
3357
3358 /**
3359 * result
3360 */
3361
3362 hc_thread_mutex_lock (mux_display);
3363
3364 check_cracked (device_param, salt_pos);
3365
3366 hc_thread_mutex_unlock (mux_display);
3367
3368 /**
3369 * progress
3370 */
3371
3372 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3373
3374 hc_thread_mutex_lock (mux_counter);
3375
3376 data.words_progress_done[salt_pos] += perf_sum_all;
3377
3378 hc_thread_mutex_unlock (mux_counter);
3379
3380 /**
3381 * speed
3382 */
3383
3384 double speed_ms;
3385
3386 hc_timer_get (device_param->timer_speed, speed_ms);
3387
3388 hc_timer_set (&device_param->timer_speed);
3389
3390 hc_thread_mutex_lock (mux_display);
3391
3392 // current speed
3393
3394 device_param->speed_cnt[speed_pos] = perf_sum_all;
3395
3396 device_param->speed_ms[speed_pos] = speed_ms;
3397
3398 hc_thread_mutex_unlock (mux_display);
3399
3400 speed_pos++;
3401
3402 if (speed_pos == SPEED_CACHE)
3403 {
3404 speed_pos = 0;
3405 }
3406
3407 /**
3408 * benchmark
3409 */
3410
3411 if (data.benchmark == 1) break;
3412 }
3413 }
3414
3415 device_param->speed_pos = speed_pos;
3416
3417 myfree (line_buf);
3418 }
3419
3420 static void load_segment (wl_data_t *wl_data, FILE *fd)
3421 {
3422 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3423
3424 wl_data->pos = 0;
3425
3426 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3427
3428 wl_data->buf[wl_data->cnt] = 0;
3429
3430 if (wl_data->cnt == 0) return;
3431
3432 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3433
3434 while (!feof (fd))
3435 {
3436 if (wl_data->cnt == wl_data->avail)
3437 {
3438 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3439
3440 wl_data->avail += wl_data->incr;
3441 }
3442
3443 const int c = fgetc (fd);
3444
3445 if (c == EOF) break;
3446
3447 wl_data->buf[wl_data->cnt] = (char) c;
3448
3449 wl_data->cnt++;
3450
3451 if (c == '\n') break;
3452 }
3453
3454 // ensure stream ends with a newline
3455
3456 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3457 {
3458 wl_data->cnt++;
3459
3460 wl_data->buf[wl_data->cnt - 1] = '\n';
3461 }
3462
3463 return;
3464 }
3465
3466 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3467 {
3468 char *ptr = buf;
3469
3470 for (u32 i = 0; i < sz; i++, ptr++)
3471 {
3472 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3473
3474 if (i == 7)
3475 {
3476 *off = i;
3477 *len = i;
3478
3479 return;
3480 }
3481
3482 if (*ptr != '\n') continue;
3483
3484 *off = i + 1;
3485
3486 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3487
3488 *len = i;
3489
3490 return;
3491 }
3492
3493 *off = sz;
3494 *len = sz;
3495 }
3496
3497 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3498 {
3499 char *ptr = buf;
3500
3501 for (u32 i = 0; i < sz; i++, ptr++)
3502 {
3503 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3504
3505 if (*ptr != '\n') continue;
3506
3507 *off = i + 1;
3508
3509 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3510
3511 *len = i;
3512
3513 return;
3514 }
3515
3516 *off = sz;
3517 *len = sz;
3518 }
3519
3520 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3521 {
3522 char *ptr = buf;
3523
3524 for (u32 i = 0; i < sz; i++, ptr++)
3525 {
3526 if (*ptr != '\n') continue;
3527
3528 *off = i + 1;
3529
3530 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3531
3532 *len = i;
3533
3534 return;
3535 }
3536
3537 *off = sz;
3538 *len = sz;
3539 }
3540
3541 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3542 {
3543 while (wl_data->pos < wl_data->cnt)
3544 {
3545 uint off;
3546 uint len;
3547
3548 char *ptr = wl_data->buf + wl_data->pos;
3549
3550 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3551
3552 wl_data->pos += off;
3553
3554 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3555 {
3556 char rule_buf_out[BLOCK_SIZE] = { 0 };
3557
3558 int rule_len_out = -1;
3559
3560 if (len < BLOCK_SIZE)
3561 {
3562 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3563 }
3564
3565 if (rule_len_out < 0)
3566 {
3567 continue;
3568 }
3569
3570 if (rule_len_out > PW_MAX)
3571 {
3572 continue;
3573 }
3574 }
3575 else
3576 {
3577 if (len > PW_MAX)
3578 {
3579 continue;
3580 }
3581 }
3582
3583 *out_buf = ptr;
3584 *out_len = len;
3585
3586 return;
3587 }
3588
3589 if (feof (fd))
3590 {
3591 fprintf (stderr, "BUG feof()!!\n");
3592
3593 return;
3594 }
3595
3596 load_segment (wl_data, fd);
3597
3598 get_next_word (wl_data, fd, out_buf, out_len);
3599 }
3600
3601 #ifdef _POSIX
3602 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3603 #endif
3604
3605 #ifdef _WIN
3606 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3607 #endif
3608 {
3609 hc_signal (NULL);
3610
3611 dictstat_t d;
3612
3613 d.cnt = 0;
3614
3615 #ifdef _POSIX
3616 fstat (fileno (fd), &d.stat);
3617 #endif
3618
3619 #ifdef _WIN
3620 _fstat64 (fileno (fd), &d.stat);
3621 #endif
3622
3623 d.stat.st_mode = 0;
3624 d.stat.st_nlink = 0;
3625 d.stat.st_uid = 0;
3626 d.stat.st_gid = 0;
3627 d.stat.st_rdev = 0;
3628 d.stat.st_atime = 0;
3629
3630 #ifdef _POSIX
3631 d.stat.st_blksize = 0;
3632 d.stat.st_blocks = 0;
3633 #endif
3634
3635 if (d.stat.st_size == 0) return 0;
3636
3637 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3638
3639 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3640 {
3641 if (d_cache)
3642 {
3643 u64 cnt = d_cache->cnt;
3644
3645 u64 keyspace = cnt;
3646
3647 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3648 {
3649 keyspace *= data.kernel_rules_cnt;
3650 }
3651 else if (data.attack_kern == ATTACK_KERN_COMBI)
3652 {
3653 keyspace *= data.combs_cnt;
3654 }
3655
3656 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);
3657 if (data.quiet == 0) log_info ("");
3658
3659 hc_signal (sigHandler_default);
3660
3661 return (keyspace);
3662 }
3663 }
3664
3665 time_t now = 0;
3666 time_t prev = 0;
3667
3668 u64 comp = 0;
3669 u64 cnt = 0;
3670 u64 cnt2 = 0;
3671
3672 while (!feof (fd))
3673 {
3674 load_segment (wl_data, fd);
3675
3676 comp += wl_data->cnt;
3677
3678 u32 i = 0;
3679
3680 while (i < wl_data->cnt)
3681 {
3682 u32 len;
3683 u32 off;
3684
3685 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3686
3687 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3688 {
3689 char rule_buf_out[BLOCK_SIZE] = { 0 };
3690
3691 int rule_len_out = -1;
3692
3693 if (len < BLOCK_SIZE)
3694 {
3695 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3696 }
3697
3698 if (rule_len_out < 0)
3699 {
3700 len = PW_MAX1;
3701 }
3702 else
3703 {
3704 len = rule_len_out;
3705 }
3706 }
3707
3708 if (len < PW_MAX1)
3709 {
3710 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3711 {
3712 cnt += data.kernel_rules_cnt;
3713 }
3714 else if (data.attack_kern == ATTACK_KERN_COMBI)
3715 {
3716 cnt += data.combs_cnt;
3717 }
3718
3719 d.cnt++;
3720 }
3721
3722 i += off;
3723
3724 cnt2++;
3725 }
3726
3727 time (&now);
3728
3729 if ((now - prev) == 0) continue;
3730
3731 float percent = (float) comp / (float) d.stat.st_size;
3732
3733 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);
3734
3735 time (&prev);
3736 }
3737
3738 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);
3739 if (data.quiet == 0) log_info ("");
3740
3741 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3742
3743 hc_signal (sigHandler_default);
3744
3745 return (cnt);
3746 }
3747
3748 static void *thread_monitor (void *p)
3749 {
3750 uint runtime_check = 0;
3751 uint remove_check = 0;
3752 uint status_check = 0;
3753 uint restore_check = 0;
3754
3755 uint restore_left = data.restore_timer;
3756 uint remove_left = data.remove_timer;
3757 uint status_left = data.status_timer;
3758
3759 #ifdef HAVE_HWMON
3760 uint hwmon_check = 0;
3761
3762 // these variables are mainly used for fan control (AMD only)
3763
3764 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3765
3766 // temperature controller "loopback" values
3767
3768 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3769 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3770
3771 #ifdef HAVE_ADL
3772 int temp_threshold = 1; // degrees celcius
3773
3774 int fan_speed_min = 15; // in percentage
3775 int fan_speed_max = 100;
3776 #endif // HAVE_ADL
3777
3778 time_t last_temp_check_time;
3779 #endif // HAVE_HWMON
3780
3781 uint sleep_time = 1;
3782
3783 if (data.runtime)
3784 {
3785 runtime_check = 1;
3786 }
3787
3788 if (data.restore_timer)
3789 {
3790 restore_check = 1;
3791 }
3792
3793 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3794 {
3795 remove_check = 1;
3796 }
3797
3798 if (data.status == 1)
3799 {
3800 status_check = 1;
3801 }
3802
3803 #ifdef HAVE_HWMON
3804 if (data.gpu_temp_disable == 0)
3805 {
3806 time (&last_temp_check_time);
3807
3808 hwmon_check = 1;
3809 }
3810 #endif
3811
3812 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3813 {
3814 #ifdef HAVE_HWMON
3815 if (hwmon_check == 0)
3816 #endif
3817 return (p);
3818 }
3819
3820 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3821 {
3822 hc_sleep (sleep_time);
3823
3824 if (data.devices_status != STATUS_RUNNING) continue;
3825
3826 #ifdef HAVE_HWMON
3827 if (hwmon_check == 1)
3828 {
3829 hc_thread_mutex_lock (mux_adl);
3830
3831 time_t temp_check_time;
3832
3833 time (&temp_check_time);
3834
3835 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3836
3837 if (Ta == 0) Ta = 1;
3838
3839 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3840 {
3841 hc_device_param_t *device_param = &data.devices_param[device_id];
3842
3843 if (device_param->skipped) continue;
3844
3845 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3846
3847 const int temperature = hm_get_temperature_with_device_id (device_id);
3848
3849 if (temperature > (int) data.gpu_temp_abort)
3850 {
3851 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3852
3853 if (data.devices_status != STATUS_QUIT) myabort ();
3854
3855 break;
3856 }
3857
3858 #ifdef HAVE_ADL
3859 const int gpu_temp_retain = data.gpu_temp_retain;
3860
3861 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3862 {
3863 if (data.hm_device[device_id].fan_supported == 1)
3864 {
3865 int temp_cur = temperature;
3866
3867 int temp_diff_new = gpu_temp_retain - temp_cur;
3868
3869 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3870
3871 // calculate Ta value (time difference in seconds between the last check and this check)
3872
3873 last_temp_check_time = temp_check_time;
3874
3875 float Kp = 1.8;
3876 float Ki = 0.005;
3877 float Kd = 6;
3878
3879 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3880
3881 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);
3882
3883 if (abs (fan_diff_required) >= temp_threshold)
3884 {
3885 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3886
3887 int fan_speed_level = fan_speed_cur;
3888
3889 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3890
3891 int fan_speed_new = fan_speed_level - fan_diff_required;
3892
3893 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3894 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3895
3896 if (fan_speed_new != fan_speed_cur)
3897 {
3898 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3899 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3900
3901 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3902 {
3903 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3904
3905 fan_speed_chgd[device_id] = 1;
3906 }
3907
3908 temp_diff_old[device_id] = temp_diff_new;
3909 }
3910 }
3911 }
3912 }
3913 #endif // HAVE_ADL
3914 }
3915
3916 hc_thread_mutex_unlock (mux_adl);
3917 }
3918 #endif // HAVE_HWMON
3919
3920 if (restore_check == 1)
3921 {
3922 restore_left--;
3923
3924 if (restore_left == 0)
3925 {
3926 if (data.restore_disable == 0) cycle_restore ();
3927
3928 restore_left = data.restore_timer;
3929 }
3930 }
3931
3932 if ((runtime_check == 1) && (data.runtime_start > 0))
3933 {
3934 time_t runtime_cur;
3935
3936 time (&runtime_cur);
3937
3938 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3939
3940 if (runtime_left <= 0)
3941 {
3942 if (data.benchmark == 0)
3943 {
3944 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3945 }
3946
3947 if (data.devices_status != STATUS_QUIT) myabort ();
3948 }
3949 }
3950
3951 if (remove_check == 1)
3952 {
3953 remove_left--;
3954
3955 if (remove_left == 0)
3956 {
3957 if (data.digests_saved != data.digests_done)
3958 {
3959 data.digests_saved = data.digests_done;
3960
3961 save_hash ();
3962 }
3963
3964 remove_left = data.remove_timer;
3965 }
3966 }
3967
3968 if (status_check == 1)
3969 {
3970 status_left--;
3971
3972 if (status_left == 0)
3973 {
3974 hc_thread_mutex_lock (mux_display);
3975
3976 if (data.quiet == 0) clear_prompt ();
3977
3978 if (data.quiet == 0) log_info ("");
3979
3980 status_display ();
3981
3982 if (data.quiet == 0) log_info ("");
3983
3984 hc_thread_mutex_unlock (mux_display);
3985
3986 status_left = data.status_timer;
3987 }
3988 }
3989 }
3990
3991 #ifdef HAVE_HWMON
3992 myfree (fan_speed_chgd);
3993
3994 myfree (temp_diff_old);
3995 myfree (temp_diff_sum);
3996 #endif
3997
3998 p = NULL;
3999
4000 return (p);
4001 }
4002
4003 static void *thread_outfile_remove (void *p)
4004 {
4005 // some hash-dependent constants
4006 char *outfile_dir = data.outfile_check_directory;
4007 uint dgst_size = data.dgst_size;
4008 uint isSalted = data.isSalted;
4009 uint esalt_size = data.esalt_size;
4010 uint hash_mode = data.hash_mode;
4011
4012 uint outfile_check_timer = data.outfile_check_timer;
4013
4014 char separator = data.separator;
4015
4016 // some hash-dependent functions
4017 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4018 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4019
4020 // buffers
4021 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4022
4023 hash_buf.digest = mymalloc (dgst_size);
4024
4025 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4026
4027 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4028
4029 uint digest_buf[64] = { 0 };
4030
4031 outfile_data_t *out_info = NULL;
4032
4033 char **out_files = NULL;
4034
4035 time_t folder_mtime = 0;
4036
4037 int out_cnt = 0;
4038
4039 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4040
4041 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4042 {
4043 hc_sleep (1);
4044
4045 if (data.devices_status != STATUS_RUNNING) continue;
4046
4047 check_left--;
4048
4049 if (check_left == 0)
4050 {
4051 struct stat outfile_check_stat;
4052
4053 if (stat (outfile_dir, &outfile_check_stat) == 0)
4054 {
4055 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4056
4057 if (is_dir == 1)
4058 {
4059 if (outfile_check_stat.st_mtime > folder_mtime)
4060 {
4061 char **out_files_new = scan_directory (outfile_dir);
4062
4063 int out_cnt_new = count_dictionaries (out_files_new);
4064
4065 outfile_data_t *out_info_new = NULL;
4066
4067 if (out_cnt_new > 0)
4068 {
4069 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4070
4071 for (int i = 0; i < out_cnt_new; i++)
4072 {
4073 out_info_new[i].file_name = out_files_new[i];
4074
4075 // check if there are files that we have seen/checked before (and not changed)
4076
4077 for (int j = 0; j < out_cnt; j++)
4078 {
4079 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4080 {
4081 struct stat outfile_stat;
4082
4083 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4084 {
4085 if (outfile_stat.st_ctime == out_info[j].ctime)
4086 {
4087 out_info_new[i].ctime = out_info[j].ctime;
4088 out_info_new[i].seek = out_info[j].seek;
4089 }
4090 }
4091 }
4092 }
4093 }
4094 }
4095
4096 local_free (out_info);
4097 local_free (out_files);
4098
4099 out_files = out_files_new;
4100 out_cnt = out_cnt_new;
4101 out_info = out_info_new;
4102
4103 folder_mtime = outfile_check_stat.st_mtime;
4104 }
4105
4106 for (int j = 0; j < out_cnt; j++)
4107 {
4108 FILE *fp = fopen (out_info[j].file_name, "rb");
4109
4110 if (fp != NULL)
4111 {
4112 //hc_thread_mutex_lock (mux_display);
4113
4114 #ifdef _POSIX
4115 struct stat outfile_stat;
4116
4117 fstat (fileno (fp), &outfile_stat);
4118 #endif
4119
4120 #ifdef _WIN
4121 struct stat64 outfile_stat;
4122
4123 _fstat64 (fileno (fp), &outfile_stat);
4124 #endif
4125
4126 if (outfile_stat.st_ctime > out_info[j].ctime)
4127 {
4128 out_info[j].ctime = outfile_stat.st_ctime;
4129 out_info[j].seek = 0;
4130 }
4131
4132 fseek (fp, out_info[j].seek, SEEK_SET);
4133
4134 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4135
4136 while (!feof (fp))
4137 {
4138 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4139
4140 if (ptr == NULL) break;
4141
4142 int line_len = strlen (line_buf);
4143
4144 if (line_len <= 0) continue;
4145
4146 int iter = MAX_CUT_TRIES;
4147
4148 for (uint i = line_len - 1; i && iter; i--, line_len--)
4149 {
4150 if (line_buf[i] != separator) continue;
4151
4152 int parser_status = PARSER_OK;
4153
4154 if ((hash_mode != 2500) && (hash_mode != 6800))
4155 {
4156 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4157 }
4158
4159 uint found = 0;
4160
4161 if (parser_status == PARSER_OK)
4162 {
4163 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4164 {
4165 if (data.salts_shown[salt_pos] == 1) continue;
4166
4167 salt_t *salt_buf = &data.salts_buf[salt_pos];
4168
4169 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4170 {
4171 uint idx = salt_buf->digests_offset + digest_pos;
4172
4173 if (data.digests_shown[idx] == 1) continue;
4174
4175 uint cracked = 0;
4176
4177 if (hash_mode == 6800)
4178 {
4179 if (i == salt_buf->salt_len)
4180 {
4181 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4182 }
4183 }
4184 else if (hash_mode == 2500)
4185 {
4186 // BSSID : MAC1 : MAC2 (:plain)
4187 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4188 {
4189 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4190
4191 if (!cracked) continue;
4192
4193 // now compare MAC1 and MAC2 too, since we have this additional info
4194 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4195 char *mac2_pos = mac1_pos + 12 + 1;
4196
4197 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4198 wpa_t *wpa = &wpas[salt_pos];
4199
4200 // compare hex string(s) vs binary MAC address(es)
4201
4202 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4203 {
4204 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4205 {
4206 cracked = 0;
4207
4208 break;
4209 }
4210 }
4211
4212 // early skip ;)
4213 if (!cracked) continue;
4214
4215 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4216 {
4217 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4218 {
4219 cracked = 0;
4220
4221 break;
4222 }
4223 }
4224 }
4225 }
4226 else
4227 {
4228 char *digests_buf_ptr = (char *) data.digests_buf;
4229
4230 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4231
4232 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4233 }
4234
4235 if (cracked == 1)
4236 {
4237 found = 1;
4238
4239 data.digests_shown[idx] = 1;
4240
4241 data.digests_done++;
4242
4243 salt_buf->digests_done++;
4244
4245 if (salt_buf->digests_done == salt_buf->digests_cnt)
4246 {
4247 data.salts_shown[salt_pos] = 1;
4248
4249 data.salts_done++;
4250
4251 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4252 }
4253 }
4254 }
4255
4256 if (data.devices_status == STATUS_CRACKED) break;
4257 }
4258 }
4259
4260 if (found) break;
4261
4262 if (data.devices_status == STATUS_CRACKED) break;
4263
4264 iter--;
4265 }
4266
4267 if (data.devices_status == STATUS_CRACKED) break;
4268 }
4269
4270 myfree (line_buf);
4271
4272 out_info[j].seek = ftell (fp);
4273
4274 //hc_thread_mutex_unlock (mux_display);
4275
4276 fclose (fp);
4277 }
4278 }
4279 }
4280 }
4281
4282 check_left = outfile_check_timer;
4283 }
4284 }
4285
4286 if (esalt_size) local_free (hash_buf.esalt);
4287
4288 if (isSalted) local_free (hash_buf.salt);
4289
4290 local_free (hash_buf.digest);
4291
4292 local_free (out_info);
4293
4294 local_free (out_files);
4295
4296 p = NULL;
4297
4298 return (p);
4299 }
4300
4301 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4302 {
4303 if (device_param->pws_cnt < device_param->kernel_power)
4304 {
4305 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4306
4307 u8 *ptr = (u8 *) pw->i;
4308
4309 memcpy (ptr, pw_buf, pw_len);
4310
4311 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4312
4313 pw->pw_len = pw_len;
4314
4315 device_param->pws_cnt++;
4316 }
4317 else
4318 {
4319 fprintf (stderr, "BUG pw_add()!!\n");
4320
4321 return;
4322 }
4323 }
4324
4325 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4326 {
4327 hc_thread_mutex_lock (mux_dispatcher);
4328
4329 const u64 words_cur = data.words_cur;
4330 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4331
4332 device_param->words_off = words_cur;
4333
4334 const u64 words_left = words_base - words_cur;
4335
4336 if (allow_div)
4337 {
4338 if (data.kernel_power_all > words_left)
4339 {
4340 if (data.kernel_power_div == 0)
4341 {
4342 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4343 }
4344 }
4345
4346 if (data.kernel_power_div)
4347 {
4348 if (device_param->kernel_power == device_param->kernel_power_user)
4349 {
4350 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4351
4352 if (kernel_power_new < device_param->kernel_power)
4353 {
4354 device_param->kernel_power = kernel_power_new;
4355 }
4356 }
4357 }
4358 }
4359
4360 const uint kernel_power = device_param->kernel_power;
4361
4362 uint work = MIN (words_left, kernel_power);
4363
4364 work = MIN (work, max);
4365
4366 data.words_cur += work;
4367
4368 hc_thread_mutex_unlock (mux_dispatcher);
4369
4370 return work;
4371 }
4372
4373 static void *thread_calc_stdin (void *p)
4374 {
4375 hc_device_param_t *device_param = (hc_device_param_t *) p;
4376
4377 if (device_param->skipped) return NULL;
4378
4379 autotune (device_param);
4380
4381 char *buf = (char *) mymalloc (HCBUFSIZ);
4382
4383 const uint attack_kern = data.attack_kern;
4384
4385 const uint kernel_power = device_param->kernel_power;
4386
4387 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4388 {
4389 hc_thread_mutex_lock (mux_dispatcher);
4390
4391 if (feof (stdin) != 0)
4392 {
4393 hc_thread_mutex_unlock (mux_dispatcher);
4394
4395 break;
4396 }
4397
4398 uint words_cur = 0;
4399
4400 while (words_cur < kernel_power)
4401 {
4402 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4403
4404 if (line_buf == NULL) break;
4405
4406 uint line_len = in_superchop (line_buf);
4407
4408 line_len = convert_from_hex (line_buf, line_len);
4409
4410 // post-process rule engine
4411
4412 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4413 {
4414 char rule_buf_out[BLOCK_SIZE] = { 0 };
4415
4416 int rule_len_out = -1;
4417
4418 if (line_len < BLOCK_SIZE)
4419 {
4420 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4421 }
4422
4423 if (rule_len_out < 0) continue;
4424
4425 line_buf = rule_buf_out;
4426 line_len = rule_len_out;
4427 }
4428
4429 if (line_len > PW_MAX)
4430 {
4431 continue;
4432 }
4433
4434 if (attack_kern == ATTACK_KERN_STRAIGHT)
4435 {
4436 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4437 {
4438 hc_thread_mutex_lock (mux_counter);
4439
4440 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4441 {
4442 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4443 }
4444
4445 hc_thread_mutex_unlock (mux_counter);
4446
4447 continue;
4448 }
4449 }
4450 else if (attack_kern == ATTACK_KERN_COMBI)
4451 {
4452 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4453 // since we still need to combine the plains
4454
4455 if (line_len > data.pw_max)
4456 {
4457 hc_thread_mutex_lock (mux_counter);
4458
4459 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4460 {
4461 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4462 }
4463
4464 hc_thread_mutex_unlock (mux_counter);
4465
4466 continue;
4467 }
4468 }
4469
4470 pw_add (device_param, (u8 *) line_buf, line_len);
4471
4472 words_cur++;
4473
4474 if (data.devices_status == STATUS_CRACKED) break;
4475 if (data.devices_status == STATUS_ABORTED) break;
4476 if (data.devices_status == STATUS_QUIT) break;
4477 if (data.devices_status == STATUS_BYPASS) break;
4478 }
4479
4480 hc_thread_mutex_unlock (mux_dispatcher);
4481
4482 if (data.devices_status == STATUS_CRACKED) break;
4483 if (data.devices_status == STATUS_ABORTED) break;
4484 if (data.devices_status == STATUS_QUIT) break;
4485 if (data.devices_status == STATUS_BYPASS) break;
4486
4487 // flush
4488
4489 const uint pws_cnt = device_param->pws_cnt;
4490
4491 if (pws_cnt)
4492 {
4493 run_copy (device_param, pws_cnt);
4494
4495 run_cracker (device_param, pws_cnt);
4496
4497 device_param->pws_cnt = 0;
4498
4499 if (attack_kern == ATTACK_KERN_STRAIGHT)
4500 {
4501 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4502 }
4503 else if (attack_kern == ATTACK_KERN_COMBI)
4504 {
4505 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4506 }
4507 }
4508 }
4509
4510 device_param->kernel_accel = 0;
4511 device_param->kernel_loops = 0;
4512
4513 myfree (buf);
4514
4515 return NULL;
4516 }
4517
4518 static void *thread_calc (void *p)
4519 {
4520 hc_device_param_t *device_param = (hc_device_param_t *) p;
4521
4522 if (device_param->skipped) return NULL;
4523
4524 autotune (device_param);
4525
4526 const uint attack_mode = data.attack_mode;
4527 const uint attack_kern = data.attack_kern;
4528
4529 if (attack_mode == ATTACK_MODE_BF)
4530 {
4531 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4532 {
4533 const uint work = get_work (device_param, -1, true);
4534
4535 if (work == 0) break;
4536
4537 const u64 words_off = device_param->words_off;
4538 const u64 words_fin = words_off + work;
4539
4540 const uint pws_cnt = work;
4541
4542 device_param->pws_cnt = pws_cnt;
4543
4544 if (pws_cnt)
4545 {
4546 run_copy (device_param, pws_cnt);
4547
4548 run_cracker (device_param, pws_cnt);
4549
4550 device_param->pws_cnt = 0;
4551
4552 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4553 }
4554
4555 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4556
4557 if (data.devices_status == STATUS_CRACKED) break;
4558 if (data.devices_status == STATUS_ABORTED) break;
4559 if (data.devices_status == STATUS_QUIT) break;
4560 if (data.devices_status == STATUS_BYPASS) break;
4561
4562 if (data.benchmark == 1) break;
4563
4564 device_param->words_done = words_fin;
4565 }
4566 }
4567 else
4568 {
4569 const uint segment_size = data.segment_size;
4570
4571 char *dictfile = data.dictfile;
4572
4573 if (attack_mode == ATTACK_MODE_COMBI)
4574 {
4575 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4576 {
4577 dictfile = data.dictfile2;
4578 }
4579 }
4580
4581 FILE *fd = fopen (dictfile, "rb");
4582
4583 if (fd == NULL)
4584 {
4585 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4586
4587 return NULL;
4588 }
4589
4590 if (attack_mode == ATTACK_MODE_COMBI)
4591 {
4592 const uint combs_mode = data.combs_mode;
4593
4594 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4595 {
4596 const char *dictfilec = data.dictfile2;
4597
4598 FILE *combs_fp = fopen (dictfilec, "rb");
4599
4600 if (combs_fp == NULL)
4601 {
4602 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4603
4604 fclose (fd);
4605
4606 return NULL;
4607 }
4608
4609 device_param->combs_fp = combs_fp;
4610 }
4611 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4612 {
4613 const char *dictfilec = data.dictfile;
4614
4615 FILE *combs_fp = fopen (dictfilec, "rb");
4616
4617 if (combs_fp == NULL)
4618 {
4619 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4620
4621 fclose (fd);
4622
4623 return NULL;
4624 }
4625
4626 device_param->combs_fp = combs_fp;
4627 }
4628 }
4629
4630 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4631
4632 wl_data->buf = (char *) mymalloc (segment_size);
4633 wl_data->avail = segment_size;
4634 wl_data->incr = segment_size;
4635 wl_data->cnt = 0;
4636 wl_data->pos = 0;
4637
4638 u64 words_cur = 0;
4639
4640 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4641 {
4642 u64 words_off = 0;
4643 u64 words_fin = 0;
4644
4645 bool allow_div = true;
4646
4647 u64 max = -1;
4648
4649 while (max)
4650 {
4651 const uint work = get_work (device_param, max, allow_div);
4652
4653 allow_div = false;
4654
4655 if (work == 0) break;
4656
4657 words_off = device_param->words_off;
4658 words_fin = words_off + work;
4659
4660 char *line_buf;
4661 uint line_len;
4662
4663 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4664
4665 max = 0;
4666
4667 for ( ; words_cur < words_fin; words_cur++)
4668 {
4669 get_next_word (wl_data, fd, &line_buf, &line_len);
4670
4671 line_len = convert_from_hex (line_buf, line_len);
4672
4673 // post-process rule engine
4674
4675 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4676 {
4677 char rule_buf_out[BLOCK_SIZE] = { 0 };
4678
4679 int rule_len_out = -1;
4680
4681 if (line_len < BLOCK_SIZE)
4682 {
4683 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4684 }
4685
4686 if (rule_len_out < 0) continue;
4687
4688 line_buf = rule_buf_out;
4689 line_len = rule_len_out;
4690 }
4691
4692 if (attack_kern == ATTACK_KERN_STRAIGHT)
4693 {
4694 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4695 {
4696 max++;
4697
4698 hc_thread_mutex_lock (mux_counter);
4699
4700 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4701 {
4702 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4703 }
4704
4705 hc_thread_mutex_unlock (mux_counter);
4706
4707 continue;
4708 }
4709 }
4710 else if (attack_kern == ATTACK_KERN_COMBI)
4711 {
4712 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4713 // since we still need to combine the plains
4714
4715 if (line_len > data.pw_max)
4716 {
4717 max++;
4718
4719 hc_thread_mutex_lock (mux_counter);
4720
4721 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4722 {
4723 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4724 }
4725
4726 hc_thread_mutex_unlock (mux_counter);
4727
4728 continue;
4729 }
4730 }
4731
4732 pw_add (device_param, (u8 *) line_buf, line_len);
4733
4734 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4735
4736 if (data.devices_status == STATUS_CRACKED) break;
4737 if (data.devices_status == STATUS_ABORTED) break;
4738 if (data.devices_status == STATUS_QUIT) break;
4739 if (data.devices_status == STATUS_BYPASS) break;
4740 }
4741
4742 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4743
4744 if (data.devices_status == STATUS_CRACKED) break;
4745 if (data.devices_status == STATUS_ABORTED) break;
4746 if (data.devices_status == STATUS_QUIT) break;
4747 if (data.devices_status == STATUS_BYPASS) break;
4748 }
4749
4750 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4751
4752 if (data.devices_status == STATUS_CRACKED) break;
4753 if (data.devices_status == STATUS_ABORTED) break;
4754 if (data.devices_status == STATUS_QUIT) break;
4755 if (data.devices_status == STATUS_BYPASS) break;
4756
4757 //
4758 // flush
4759 //
4760
4761 const uint pws_cnt = device_param->pws_cnt;
4762
4763 if (pws_cnt)
4764 {
4765 run_copy (device_param, pws_cnt);
4766
4767 run_cracker (device_param, pws_cnt);
4768
4769 device_param->pws_cnt = 0;
4770
4771 if (attack_kern == ATTACK_KERN_STRAIGHT)
4772 {
4773 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4774 }
4775 else if (attack_kern == ATTACK_KERN_COMBI)
4776 {
4777 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4778 }
4779 }
4780
4781 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4782
4783 if (data.devices_status == STATUS_CRACKED) break;
4784 if (data.devices_status == STATUS_ABORTED) break;
4785 if (data.devices_status == STATUS_QUIT) break;
4786 if (data.devices_status == STATUS_BYPASS) break;
4787
4788 if (words_fin == 0) break;
4789
4790 device_param->words_done = words_fin;
4791 }
4792
4793 if (attack_mode == ATTACK_MODE_COMBI)
4794 {
4795 fclose (device_param->combs_fp);
4796 }
4797
4798 free (wl_data->buf);
4799 free (wl_data);
4800
4801 fclose (fd);
4802 }
4803
4804 device_param->kernel_accel = 0;
4805 device_param->kernel_loops = 0;
4806
4807 return NULL;
4808 }
4809
4810 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4811 {
4812 if (!device_param)
4813 {
4814 log_error ("ERROR: %s : Invalid argument", __func__);
4815
4816 exit (-1);
4817 }
4818
4819 salt_t *salt_buf = &data.salts_buf[salt_pos];
4820
4821 device_param->kernel_params_buf32[24] = salt_pos;
4822 device_param->kernel_params_buf32[27] = 1;
4823 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4824 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4825 device_param->kernel_params_buf32[30] = 0;
4826 device_param->kernel_params_buf32[31] = 1;
4827
4828 char *dictfile_old = data.dictfile;
4829
4830 const char *weak_hash_check = "weak-hash-check";
4831
4832 data.dictfile = (char *) weak_hash_check;
4833
4834 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4835
4836 data.kernel_rules_buf[0].cmds[0] = 0;
4837
4838 /**
4839 * run the kernel
4840 */
4841
4842 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4843 {
4844 run_kernel (KERN_RUN_1, device_param, 1, false);
4845 }
4846 else
4847 {
4848 run_kernel (KERN_RUN_1, device_param, 1, false);
4849
4850 uint loop_step = 16;
4851
4852 const uint iter = salt_buf->salt_iter;
4853
4854 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4855 {
4856 uint loop_left = iter - loop_pos;
4857
4858 loop_left = MIN (loop_left, loop_step);
4859
4860 device_param->kernel_params_buf32[25] = loop_pos;
4861 device_param->kernel_params_buf32[26] = loop_left;
4862
4863 run_kernel (KERN_RUN_2, device_param, 1, false);
4864 }
4865
4866 run_kernel (KERN_RUN_3, device_param, 1, false);
4867 }
4868
4869 /**
4870 * result
4871 */
4872
4873 check_cracked (device_param, salt_pos);
4874
4875 /**
4876 * cleanup
4877 */
4878
4879 device_param->kernel_params_buf32[24] = 0;
4880 device_param->kernel_params_buf32[25] = 0;
4881 device_param->kernel_params_buf32[26] = 0;
4882 device_param->kernel_params_buf32[27] = 0;
4883 device_param->kernel_params_buf32[28] = 0;
4884 device_param->kernel_params_buf32[29] = 0;
4885 device_param->kernel_params_buf32[30] = 0;
4886 device_param->kernel_params_buf32[31] = 0;
4887
4888 data.dictfile = dictfile_old;
4889
4890 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4891 }
4892
4893 // hlfmt hashcat
4894
4895 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4896 {
4897 if (data.username == 0)
4898 {
4899 *hashbuf_pos = line_buf;
4900 *hashbuf_len = line_len;
4901 }
4902 else
4903 {
4904 char *pos = line_buf;
4905 int len = line_len;
4906
4907 for (int i = 0; i < line_len; i++, pos++, len--)
4908 {
4909 if (line_buf[i] == data.separator)
4910 {
4911 pos++;
4912
4913 len--;
4914
4915 break;
4916 }
4917 }
4918
4919 *hashbuf_pos = pos;
4920 *hashbuf_len = len;
4921 }
4922 }
4923
4924 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4925 {
4926 char *pos = NULL;
4927 int len = 0;
4928
4929 int sep_cnt = 0;
4930
4931 for (int i = 0; i < line_len; i++)
4932 {
4933 if (line_buf[i] == data.separator)
4934 {
4935 sep_cnt++;
4936
4937 continue;
4938 }
4939
4940 if (sep_cnt == 0)
4941 {
4942 if (pos == NULL) pos = line_buf + i;
4943
4944 len++;
4945 }
4946 }
4947
4948 *userbuf_pos = pos;
4949 *userbuf_len = len;
4950 }
4951
4952 // hlfmt pwdump
4953
4954 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4955 {
4956 int sep_cnt = 0;
4957
4958 int sep2_len = 0;
4959 int sep3_len = 0;
4960
4961 for (int i = 0; i < line_len; i++)
4962 {
4963 if (line_buf[i] == ':')
4964 {
4965 sep_cnt++;
4966
4967 continue;
4968 }
4969
4970 if (sep_cnt == 2) sep2_len++;
4971 if (sep_cnt == 3) sep3_len++;
4972 }
4973
4974 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4975
4976 return 0;
4977 }
4978
4979 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4980 {
4981 char *pos = NULL;
4982 int len = 0;
4983
4984 int sep_cnt = 0;
4985
4986 for (int i = 0; i < line_len; i++)
4987 {
4988 if (line_buf[i] == ':')
4989 {
4990 sep_cnt++;
4991
4992 continue;
4993 }
4994
4995 if (data.hash_mode == 1000)
4996 {
4997 if (sep_cnt == 3)
4998 {
4999 if (pos == NULL) pos = line_buf + i;
5000
5001 len++;
5002 }
5003 }
5004 else if (data.hash_mode == 3000)
5005 {
5006 if (sep_cnt == 2)
5007 {
5008 if (pos == NULL) pos = line_buf + i;
5009
5010 len++;
5011 }
5012 }
5013 }
5014
5015 *hashbuf_pos = pos;
5016 *hashbuf_len = len;
5017 }
5018
5019 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5020 {
5021 char *pos = NULL;
5022 int len = 0;
5023
5024 int sep_cnt = 0;
5025
5026 for (int i = 0; i < line_len; i++)
5027 {
5028 if (line_buf[i] == ':')
5029 {
5030 sep_cnt++;
5031
5032 continue;
5033 }
5034
5035 if (sep_cnt == 0)
5036 {
5037 if (pos == NULL) pos = line_buf + i;
5038
5039 len++;
5040 }
5041 }
5042
5043 *userbuf_pos = pos;
5044 *userbuf_len = len;
5045 }
5046
5047 // hlfmt passwd
5048
5049 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5050 {
5051 int sep_cnt = 0;
5052
5053 char sep5_first = 0;
5054 char sep6_first = 0;
5055
5056 for (int i = 0; i < line_len; i++)
5057 {
5058 if (line_buf[i] == ':')
5059 {
5060 sep_cnt++;
5061
5062 continue;
5063 }
5064
5065 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5066 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5067 }
5068
5069 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5070
5071 return 0;
5072 }
5073
5074 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5075 {
5076 char *pos = NULL;
5077 int len = 0;
5078
5079 int sep_cnt = 0;
5080
5081 for (int i = 0; i < line_len; i++)
5082 {
5083 if (line_buf[i] == ':')
5084 {
5085 sep_cnt++;
5086
5087 continue;
5088 }
5089
5090 if (sep_cnt == 1)
5091 {
5092 if (pos == NULL) pos = line_buf + i;
5093
5094 len++;
5095 }
5096 }
5097
5098 *hashbuf_pos = pos;
5099 *hashbuf_len = len;
5100 }
5101
5102 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5103 {
5104 char *pos = NULL;
5105 int len = 0;
5106
5107 int sep_cnt = 0;
5108
5109 for (int i = 0; i < line_len; i++)
5110 {
5111 if (line_buf[i] == ':')
5112 {
5113 sep_cnt++;
5114
5115 continue;
5116 }
5117
5118 if (sep_cnt == 0)
5119 {
5120 if (pos == NULL) pos = line_buf + i;
5121
5122 len++;
5123 }
5124 }
5125
5126 *userbuf_pos = pos;
5127 *userbuf_len = len;
5128 }
5129
5130 // hlfmt shadow
5131
5132 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5133 {
5134 int sep_cnt = 0;
5135
5136 for (int i = 0; i < line_len; i++)
5137 {
5138 if (line_buf[i] == ':') sep_cnt++;
5139 }
5140
5141 if (sep_cnt == 8) return 1;
5142
5143 return 0;
5144 }
5145
5146 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5147 {
5148 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5149 }
5150
5151 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5152 {
5153 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5154 }
5155
5156 // hlfmt main
5157
5158 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5159 {
5160 switch (hashfile_format)
5161 {
5162 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5163 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5164 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5165 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5166 }
5167 }
5168
5169 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5170 {
5171 switch (hashfile_format)
5172 {
5173 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5174 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5175 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5176 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5177 }
5178 }
5179
5180 char *strhlfmt (const uint hashfile_format)
5181 {
5182 switch (hashfile_format)
5183 {
5184 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5185 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5186 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5187 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5188 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5189 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5190 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5191 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5192 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5193 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5194 }
5195
5196 return ((char *) "Unknown");
5197 }
5198
5199 static uint hlfmt_detect (FILE *fp, uint max_check)
5200 {
5201 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5202
5203 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5204 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5205
5206 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5207
5208 uint num_check = 0;
5209
5210 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5211
5212 while (!feof (fp))
5213 {
5214 int line_len = fgetl (fp, line_buf);
5215
5216 if (line_len == 0) continue;
5217
5218 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5219 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5220 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5221
5222 if (num_check == max_check) break;
5223
5224 num_check++;
5225 }
5226
5227 myfree (line_buf);
5228
5229 uint hashlist_format = HLFMT_HASHCAT;
5230
5231 for (int i = 1; i < HLFMTS_CNT; i++)
5232 {
5233 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5234
5235 hashlist_format = i;
5236 }
5237
5238 free (formats_cnt);
5239
5240 return hashlist_format;
5241 }
5242
5243 /**
5244 * some further helper function
5245 */
5246
5247 // wrapper around mymalloc for ADL
5248
5249 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5250 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5251 {
5252 return mymalloc (iSize);
5253 }
5254 #endif
5255
5256 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)
5257 {
5258 u64 collisions = 0;
5259
5260 const uint dgst_pos0 = data.dgst_pos0;
5261 const uint dgst_pos1 = data.dgst_pos1;
5262 const uint dgst_pos2 = data.dgst_pos2;
5263 const uint dgst_pos3 = data.dgst_pos3;
5264
5265 memset (bitmap_a, 0, bitmap_size);
5266 memset (bitmap_b, 0, bitmap_size);
5267 memset (bitmap_c, 0, bitmap_size);
5268 memset (bitmap_d, 0, bitmap_size);
5269
5270 for (uint i = 0; i < digests_cnt; i++)
5271 {
5272 uint *digest_ptr = (uint *) digests_buf_ptr;
5273
5274 digests_buf_ptr += dgst_size;
5275
5276 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5277 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5278 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5279 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5280
5281 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5282 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5283 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5284 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5285
5286 if (bitmap_a[idx0] & val0) collisions++;
5287 if (bitmap_b[idx1] & val1) collisions++;
5288 if (bitmap_c[idx2] & val2) collisions++;
5289 if (bitmap_d[idx3] & val3) collisions++;
5290
5291 bitmap_a[idx0] |= val0;
5292 bitmap_b[idx1] |= val1;
5293 bitmap_c[idx2] |= val2;
5294 bitmap_d[idx3] |= val3;
5295
5296 if (collisions >= collisions_max) return 0x7fffffff;
5297 }
5298
5299 return collisions;
5300 }
5301
5302 /**
5303 * main
5304 */
5305
5306 int main (int argc, char **argv)
5307 {
5308 /**
5309 * To help users a bit
5310 */
5311
5312 char *compute = getenv ("COMPUTE");
5313
5314 if (compute)
5315 {
5316 static char display[100];
5317
5318 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5319
5320 putenv (display);
5321 }
5322 else
5323 {
5324 if (getenv ("DISPLAY") == NULL)
5325 putenv ((char *) "DISPLAY=:0");
5326 }
5327
5328 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5329 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5330
5331 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5332 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5333
5334 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5335 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5336
5337 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5338 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5339
5340 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5341 putenv ((char *) "POCL_KERNEL_CACHE=0");
5342
5343 /**
5344 * Real init
5345 */
5346
5347 memset (&data, 0, sizeof (hc_global_data_t));
5348
5349 time_t proc_start;
5350
5351 time (&proc_start);
5352
5353 data.proc_start = proc_start;
5354
5355 int myargc = argc;
5356 char **myargv = argv;
5357
5358 hc_thread_mutex_init (mux_dispatcher);
5359 hc_thread_mutex_init (mux_counter);
5360 hc_thread_mutex_init (mux_display);
5361 hc_thread_mutex_init (mux_adl);
5362
5363 /**
5364 * commandline parameters
5365 */
5366
5367 uint usage = USAGE;
5368 uint version = VERSION;
5369 uint quiet = QUIET;
5370 uint benchmark = BENCHMARK;
5371 uint benchmark_repeats = BENCHMARK_REPEATS;
5372 uint show = SHOW;
5373 uint left = LEFT;
5374 uint username = USERNAME;
5375 uint remove = REMOVE;
5376 uint remove_timer = REMOVE_TIMER;
5377 u64 skip = SKIP;
5378 u64 limit = LIMIT;
5379 uint keyspace = KEYSPACE;
5380 uint potfile_disable = POTFILE_DISABLE;
5381 char *potfile_path = NULL;
5382 uint debug_mode = DEBUG_MODE;
5383 char *debug_file = NULL;
5384 char *induction_dir = NULL;
5385 char *outfile_check_dir = NULL;
5386 uint force = FORCE;
5387 uint runtime = RUNTIME;
5388 uint hash_mode = HASH_MODE;
5389 uint attack_mode = ATTACK_MODE;
5390 uint markov_disable = MARKOV_DISABLE;
5391 uint markov_classic = MARKOV_CLASSIC;
5392 uint markov_threshold = MARKOV_THRESHOLD;
5393 char *markov_hcstat = NULL;
5394 char *outfile = NULL;
5395 uint outfile_format = OUTFILE_FORMAT;
5396 uint outfile_autohex = OUTFILE_AUTOHEX;
5397 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5398 uint restore = RESTORE;
5399 uint restore_timer = RESTORE_TIMER;
5400 uint restore_disable = RESTORE_DISABLE;
5401 uint status = STATUS;
5402 uint status_timer = STATUS_TIMER;
5403 uint status_automat = STATUS_AUTOMAT;
5404 uint loopback = LOOPBACK;
5405 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5406 char *session = NULL;
5407 uint hex_charset = HEX_CHARSET;
5408 uint hex_salt = HEX_SALT;
5409 uint hex_wordlist = HEX_WORDLIST;
5410 uint rp_gen = RP_GEN;
5411 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5412 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5413 uint rp_gen_seed = RP_GEN_SEED;
5414 char *rule_buf_l = (char *) RULE_BUF_L;
5415 char *rule_buf_r = (char *) RULE_BUF_R;
5416 uint increment = INCREMENT;
5417 uint increment_min = INCREMENT_MIN;
5418 uint increment_max = INCREMENT_MAX;
5419 char *cpu_affinity = NULL;
5420 OCL_PTR *ocl = NULL;
5421 char *opencl_devices = NULL;
5422 char *opencl_platforms = NULL;
5423 char *opencl_device_types = NULL;
5424 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5425 char *truecrypt_keyfiles = NULL;
5426 uint workload_profile = WORKLOAD_PROFILE;
5427 uint kernel_accel = KERNEL_ACCEL;
5428 uint kernel_loops = KERNEL_LOOPS;
5429 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5430 #ifdef HAVE_HWMON
5431 uint gpu_temp_abort = GPU_TEMP_ABORT;
5432 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5433 #ifdef HAVE_ADL
5434 uint powertune_enable = POWERTUNE_ENABLE;
5435 #endif
5436 #endif
5437 uint logfile_disable = LOGFILE_DISABLE;
5438 uint segment_size = SEGMENT_SIZE;
5439 uint scrypt_tmto = SCRYPT_TMTO;
5440 char separator = SEPARATOR;
5441 uint bitmap_min = BITMAP_MIN;
5442 uint bitmap_max = BITMAP_MAX;
5443 char *custom_charset_1 = NULL;
5444 char *custom_charset_2 = NULL;
5445 char *custom_charset_3 = NULL;
5446 char *custom_charset_4 = NULL;
5447
5448 #define IDX_HELP 'h'
5449 #define IDX_VERSION 'V'
5450 #define IDX_VERSION_LOWER 'v'
5451 #define IDX_QUIET 0xff02
5452 #define IDX_SHOW 0xff03
5453 #define IDX_LEFT 0xff04
5454 #define IDX_REMOVE 0xff05
5455 #define IDX_REMOVE_TIMER 0xff37
5456 #define IDX_SKIP 's'
5457 #define IDX_LIMIT 'l'
5458 #define IDX_KEYSPACE 0xff35
5459 #define IDX_POTFILE_DISABLE 0xff06
5460 #define IDX_POTFILE_PATH 0xffe0
5461 #define IDX_DEBUG_MODE 0xff43
5462 #define IDX_DEBUG_FILE 0xff44
5463 #define IDX_INDUCTION_DIR 0xff46
5464 #define IDX_OUTFILE_CHECK_DIR 0xff47
5465 #define IDX_USERNAME 0xff07
5466 #define IDX_FORCE 0xff08
5467 #define IDX_RUNTIME 0xff09
5468 #define IDX_BENCHMARK 'b'
5469 #define IDX_BENCHMARK_REPEATS 0xff78
5470 #define IDX_HASH_MODE 'm'
5471 #define IDX_ATTACK_MODE 'a'
5472 #define IDX_RP_FILE 'r'
5473 #define IDX_RP_GEN 'g'
5474 #define IDX_RP_GEN_FUNC_MIN 0xff10
5475 #define IDX_RP_GEN_FUNC_MAX 0xff11
5476 #define IDX_RP_GEN_SEED 0xff34
5477 #define IDX_RULE_BUF_L 'j'
5478 #define IDX_RULE_BUF_R 'k'
5479 #define IDX_INCREMENT 'i'
5480 #define IDX_INCREMENT_MIN 0xff12
5481 #define IDX_INCREMENT_MAX 0xff13
5482 #define IDX_OUTFILE 'o'
5483 #define IDX_OUTFILE_FORMAT 0xff14
5484 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5485 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5486 #define IDX_RESTORE 0xff15
5487 #define IDX_RESTORE_DISABLE 0xff27
5488 #define IDX_STATUS 0xff17
5489 #define IDX_STATUS_TIMER 0xff18
5490 #define IDX_STATUS_AUTOMAT 0xff50
5491 #define IDX_LOOPBACK 0xff38
5492 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5493 #define IDX_SESSION 0xff19
5494 #define IDX_HEX_CHARSET 0xff20
5495 #define IDX_HEX_SALT 0xff21
5496 #define IDX_HEX_WORDLIST 0xff40
5497 #define IDX_MARKOV_DISABLE 0xff22
5498 #define IDX_MARKOV_CLASSIC 0xff23
5499 #define IDX_MARKOV_THRESHOLD 't'
5500 #define IDX_MARKOV_HCSTAT 0xff24
5501 #define IDX_CPU_AFFINITY 0xff25
5502 #define IDX_OPENCL_DEVICES 'd'
5503 #define IDX_OPENCL_PLATFORMS 0xff72
5504 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5505 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5506 #define IDX_WORKLOAD_PROFILE 'w'
5507 #define IDX_KERNEL_ACCEL 'n'
5508 #define IDX_KERNEL_LOOPS 'u'
5509 #define IDX_GPU_TEMP_DISABLE 0xff29
5510 #define IDX_GPU_TEMP_ABORT 0xff30
5511 #define IDX_GPU_TEMP_RETAIN 0xff31
5512 #define IDX_POWERTUNE_ENABLE 0xff41
5513 #define IDX_LOGFILE_DISABLE 0xff51
5514 #define IDX_TRUECRYPT_KEYFILES 0xff52
5515 #define IDX_SCRYPT_TMTO 0xff61
5516 #define IDX_SEGMENT_SIZE 'c'
5517 #define IDX_SEPARATOR 'p'
5518 #define IDX_BITMAP_MIN 0xff70
5519 #define IDX_BITMAP_MAX 0xff71
5520 #define IDX_CUSTOM_CHARSET_1 '1'
5521 #define IDX_CUSTOM_CHARSET_2 '2'
5522 #define IDX_CUSTOM_CHARSET_3 '3'
5523 #define IDX_CUSTOM_CHARSET_4 '4'
5524
5525 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5526
5527 struct option long_options[] =
5528 {
5529 {"help", no_argument, 0, IDX_HELP},
5530 {"version", no_argument, 0, IDX_VERSION},
5531 {"quiet", no_argument, 0, IDX_QUIET},
5532 {"show", no_argument, 0, IDX_SHOW},
5533 {"left", no_argument, 0, IDX_LEFT},
5534 {"username", no_argument, 0, IDX_USERNAME},
5535 {"remove", no_argument, 0, IDX_REMOVE},
5536 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5537 {"skip", required_argument, 0, IDX_SKIP},
5538 {"limit", required_argument, 0, IDX_LIMIT},
5539 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5540 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5541 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5542 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5543 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5544 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5545 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5546 {"force", no_argument, 0, IDX_FORCE},
5547 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5548 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5549 {"restore", no_argument, 0, IDX_RESTORE},
5550 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5551 {"status", no_argument, 0, IDX_STATUS},
5552 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5553 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5554 {"loopback", no_argument, 0, IDX_LOOPBACK},
5555 {"weak-hash-threshold",
5556 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5557 {"session", required_argument, 0, IDX_SESSION},
5558 {"runtime", required_argument, 0, IDX_RUNTIME},
5559 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5560 {"generate-rules-func-min",
5561 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5562 {"generate-rules-func-max",
5563 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5564 {"generate-rules-seed",
5565 required_argument, 0, IDX_RP_GEN_SEED},
5566 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5567 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5568 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5569 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5570 {"rules-file", required_argument, 0, IDX_RP_FILE},
5571 {"outfile", required_argument, 0, IDX_OUTFILE},
5572 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5573 {"outfile-autohex-disable",
5574 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5575 {"outfile-check-timer",
5576 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5577 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5578 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5579 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5580 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5581 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5582 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5583 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5584 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5585 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5586 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5587 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5588 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5589 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5590 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5591 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5592 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5593 #ifdef HAVE_HWMON
5594 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5595 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5596 #ifdef HAVE_ADL
5597 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5598 #endif
5599 #endif // HAVE_HWMON
5600 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5601 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5602 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5603 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5604 // deprecated
5605 {"seperator", required_argument, 0, IDX_SEPARATOR},
5606 {"separator", required_argument, 0, IDX_SEPARATOR},
5607 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5608 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5609 {"increment", no_argument, 0, IDX_INCREMENT},
5610 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5611 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5612 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5613 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5614 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5615 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5616
5617 {0, 0, 0, 0}
5618 };
5619
5620 uint rp_files_cnt = 0;
5621
5622 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5623
5624 int option_index = 0;
5625 int c = -1;
5626
5627 optind = 1;
5628 optopt = 0;
5629
5630 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5631 {
5632 switch (c)
5633 {
5634 case IDX_HELP: usage = 1; break;
5635 case IDX_VERSION:
5636 case IDX_VERSION_LOWER: version = 1; break;
5637 case IDX_RESTORE: restore = 1; break;
5638 case IDX_SESSION: session = optarg; break;
5639 case IDX_SHOW: show = 1; break;
5640 case IDX_LEFT: left = 1; break;
5641 case '?': return (-1);
5642 }
5643 }
5644
5645 if (optopt != 0)
5646 {
5647 log_error ("ERROR: Invalid argument specified");
5648
5649 return (-1);
5650 }
5651
5652 /**
5653 * exit functions
5654 */
5655
5656 if (version)
5657 {
5658 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5659
5660 return (0);
5661 }
5662
5663 if (usage)
5664 {
5665 usage_big_print (PROGNAME);
5666
5667 return (0);
5668 }
5669
5670 /**
5671 * session needs to be set, always!
5672 */
5673
5674 if (session == NULL) session = (char *) PROGNAME;
5675
5676 /**
5677 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5678 */
5679
5680 char *exec_path = get_exec_path ();
5681
5682 #ifdef LINUX
5683
5684 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5685 char *resolved_exec_path = realpath (exec_path, NULL);
5686
5687 char *install_dir = get_install_dir (resolved_exec_path);
5688 char *profile_dir = NULL;
5689 char *session_dir = NULL;
5690 char *shared_dir = NULL;
5691
5692 if (strcmp (install_dir, resolved_install_folder) == 0)
5693 {
5694 struct passwd *pw = getpwuid (getuid ());
5695
5696 const char *homedir = pw->pw_dir;
5697
5698 profile_dir = get_profile_dir (homedir);
5699 session_dir = get_session_dir (profile_dir);
5700 shared_dir = strdup (SHARED_FOLDER);
5701
5702 mkdir (profile_dir, 0700);
5703 mkdir (session_dir, 0700);
5704 }
5705 else
5706 {
5707 profile_dir = install_dir;
5708 session_dir = install_dir;
5709 shared_dir = install_dir;
5710 }
5711
5712 myfree (resolved_install_folder);
5713 myfree (resolved_exec_path);
5714
5715 #else
5716
5717 char *install_dir = get_install_dir (exec_path);
5718 char *profile_dir = install_dir;
5719 char *session_dir = install_dir;
5720 char *shared_dir = install_dir;
5721
5722 #endif
5723
5724 data.install_dir = install_dir;
5725 data.profile_dir = profile_dir;
5726 data.session_dir = session_dir;
5727 data.shared_dir = shared_dir;
5728
5729 myfree (exec_path);
5730
5731 /**
5732 * kernel cache, we need to make sure folder exist
5733 */
5734
5735 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5736
5737 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5738
5739 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5740
5741 mkdir (kernels_folder, 0700);
5742
5743 myfree (kernels_folder);
5744
5745 /**
5746 * session
5747 */
5748
5749 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5750
5751 data.session = session;
5752
5753 char *eff_restore_file = (char *) mymalloc (session_size);
5754 char *new_restore_file = (char *) mymalloc (session_size);
5755
5756 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5757 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5758
5759 data.eff_restore_file = eff_restore_file;
5760 data.new_restore_file = new_restore_file;
5761
5762 if (((show == 1) || (left == 1)) && (restore == 1))
5763 {
5764 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5765 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5766
5767 return (-1);
5768 }
5769
5770 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5771 if ((show == 1) || (left == 1))
5772 {
5773 restore_disable = 1;
5774
5775 restore = 0;
5776 }
5777
5778 data.restore_disable = restore_disable;
5779
5780 restore_data_t *rd = init_restore (argc, argv);
5781
5782 data.rd = rd;
5783
5784 /**
5785 * restore file
5786 */
5787
5788 if (restore == 1)
5789 {
5790 read_restore (eff_restore_file, rd);
5791
5792 if (rd->version_bin < RESTORE_MIN)
5793 {
5794 log_error ("ERROR: Incompatible restore-file version");
5795
5796 return (-1);
5797 }
5798
5799 myargc = rd->argc;
5800 myargv = rd->argv;
5801
5802 #ifdef _POSIX
5803 rd->pid = getpid ();
5804 #elif _WIN
5805 rd->pid = GetCurrentProcessId ();
5806 #endif
5807 }
5808
5809 uint hash_mode_chgd = 0;
5810 uint runtime_chgd = 0;
5811 uint kernel_loops_chgd = 0;
5812 uint kernel_accel_chgd = 0;
5813 uint attack_mode_chgd = 0;
5814 uint outfile_format_chgd = 0;
5815 uint rp_gen_seed_chgd = 0;
5816 uint remove_timer_chgd = 0;
5817 uint increment_min_chgd = 0;
5818 uint increment_max_chgd = 0;
5819 uint workload_profile_chgd = 0;
5820 uint opencl_vector_width_chgd = 0;
5821
5822 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5823 uint gpu_temp_retain_chgd = 0;
5824 uint gpu_temp_abort_chgd = 0;
5825 #endif
5826
5827 optind = 1;
5828 optopt = 0;
5829 option_index = 0;
5830
5831 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5832 {
5833 switch (c)
5834 {
5835 //case IDX_HELP: usage = 1; break;
5836 //case IDX_VERSION: version = 1; break;
5837 //case IDX_RESTORE: restore = 1; break;
5838 case IDX_QUIET: quiet = 1; break;
5839 //case IDX_SHOW: show = 1; break;
5840 case IDX_SHOW: break;
5841 //case IDX_LEFT: left = 1; break;
5842 case IDX_LEFT: break;
5843 case IDX_USERNAME: username = 1; break;
5844 case IDX_REMOVE: remove = 1; break;
5845 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5846 remove_timer_chgd = 1; break;
5847 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5848 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5849 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5850 case IDX_DEBUG_FILE: debug_file = optarg; break;
5851 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5852 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5853 case IDX_FORCE: force = 1; break;
5854 case IDX_SKIP: skip = atoll (optarg); break;
5855 case IDX_LIMIT: limit = atoll (optarg); break;
5856 case IDX_KEYSPACE: keyspace = 1; break;
5857 case IDX_BENCHMARK: benchmark = 1; break;
5858 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5859 case IDX_RESTORE: break;
5860 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5861 case IDX_STATUS: status = 1; break;
5862 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5863 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5864 case IDX_LOOPBACK: loopback = 1; break;
5865 case IDX_WEAK_HASH_THRESHOLD:
5866 weak_hash_threshold = atoi (optarg); break;
5867 //case IDX_SESSION: session = optarg; break;
5868 case IDX_SESSION: break;
5869 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5870 hash_mode_chgd = 1; break;
5871 case IDX_RUNTIME: runtime = atoi (optarg);
5872 runtime_chgd = 1; break;
5873 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5874 attack_mode_chgd = 1; break;
5875 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5876 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5877 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5878 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5879 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5880 rp_gen_seed_chgd = 1; break;
5881 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5882 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5883 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5884 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5885 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5886 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5887 case IDX_OUTFILE: outfile = optarg; break;
5888 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5889 outfile_format_chgd = 1; break;
5890 case IDX_OUTFILE_AUTOHEX_DISABLE:
5891 outfile_autohex = 0; break;
5892 case IDX_OUTFILE_CHECK_TIMER:
5893 outfile_check_timer = atoi (optarg); break;
5894 case IDX_HEX_CHARSET: hex_charset = 1; break;
5895 case IDX_HEX_SALT: hex_salt = 1; break;
5896 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5897 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5898 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5899 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5900 case IDX_OPENCL_DEVICE_TYPES:
5901 opencl_device_types = optarg; break;
5902 case IDX_OPENCL_VECTOR_WIDTH:
5903 opencl_vector_width = atoi (optarg);
5904 opencl_vector_width_chgd = 1; break;
5905 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5906 workload_profile_chgd = 1; break;
5907 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5908 kernel_accel_chgd = 1; break;
5909 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5910 kernel_loops_chgd = 1; break;
5911 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5912 #ifdef HAVE_HWMON
5913 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5914 #ifdef HAVE_ADL
5915 gpu_temp_abort_chgd = 1;
5916 #endif
5917 break;
5918 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5919 #ifdef HAVE_ADL
5920 gpu_temp_retain_chgd = 1;
5921 #endif
5922 break;
5923 #ifdef HAVE_ADL
5924 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5925 #endif
5926 #endif // HAVE_HWMON
5927 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5928 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5929 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5930 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5931 case IDX_SEPARATOR: separator = optarg[0]; break;
5932 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5933 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5934 case IDX_INCREMENT: increment = 1; break;
5935 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5936 increment_min_chgd = 1; break;
5937 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5938 increment_max_chgd = 1; break;
5939 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5940 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5941 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5942 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5943
5944 default:
5945 log_error ("ERROR: Invalid argument specified");
5946 return (-1);
5947 }
5948 }
5949
5950 if (optopt != 0)
5951 {
5952 log_error ("ERROR: Invalid argument specified");
5953
5954 return (-1);
5955 }
5956
5957 /**
5958 * Inform user things getting started,
5959 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5960 * - we do not need to check algorithm_pos
5961 */
5962
5963 if (quiet == 0)
5964 {
5965 if (benchmark == 1)
5966 {
5967 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5968
5969 log_info ("");
5970 }
5971 else if (restore == 1)
5972 {
5973 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5974
5975 log_info ("");
5976 }
5977 else
5978 {
5979 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5980
5981 log_info ("");
5982 }
5983 }
5984
5985 /**
5986 * sanity check
5987 */
5988
5989 if (attack_mode > 7)
5990 {
5991 log_error ("ERROR: Invalid attack-mode specified");
5992
5993 return (-1);
5994 }
5995
5996 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5997 {
5998 log_error ("ERROR: Invalid runtime specified");
5999
6000 return (-1);
6001 }
6002
6003 if (hash_mode_chgd && hash_mode > 13500) // just added to remove compiler warnings for hash_mode_chgd
6004 {
6005 log_error ("ERROR: Invalid hash-type specified");
6006
6007 return (-1);
6008 }
6009
6010 // renamed hash modes
6011
6012 if (hash_mode_chgd)
6013 {
6014 int n = -1;
6015
6016 switch (hash_mode)
6017 {
6018 case 123: n = 124;
6019 break;
6020 }
6021
6022 if (n >= 0)
6023 {
6024 log_error ("Old -m specified, use -m %d instead", n);
6025
6026 return (-1);
6027 }
6028 }
6029
6030 if (username == 1)
6031 {
6032 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6033 {
6034 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6035
6036 return (-1);
6037 }
6038 }
6039
6040 if (outfile_format > 16)
6041 {
6042 log_error ("ERROR: Invalid outfile-format specified");
6043
6044 return (-1);
6045 }
6046
6047 if (left == 1)
6048 {
6049 if (outfile_format_chgd == 1)
6050 {
6051 if (outfile_format > 1)
6052 {
6053 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6054
6055 return (-1);
6056 }
6057 }
6058 else
6059 {
6060 outfile_format = OUTFILE_FMT_HASH;
6061 }
6062 }
6063
6064 if (show == 1)
6065 {
6066 if (outfile_format_chgd == 1)
6067 {
6068 if ((outfile_format > 7) && (outfile_format < 16))
6069 {
6070 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6071
6072 return (-1);
6073 }
6074 }
6075 }
6076
6077 if (increment_min < INCREMENT_MIN)
6078 {
6079 log_error ("ERROR: Invalid increment-min specified");
6080
6081 return (-1);
6082 }
6083
6084 if (increment_max > INCREMENT_MAX)
6085 {
6086 log_error ("ERROR: Invalid increment-max specified");
6087
6088 return (-1);
6089 }
6090
6091 if (increment_min > increment_max)
6092 {
6093 log_error ("ERROR: Invalid increment-min specified");
6094
6095 return (-1);
6096 }
6097
6098 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6099 {
6100 log_error ("ERROR: increment is not allowed in attack-mode 0");
6101
6102 return (-1);
6103 }
6104
6105 if ((increment == 0) && (increment_min_chgd == 1))
6106 {
6107 log_error ("ERROR: increment-min is only supported together with increment switch");
6108
6109 return (-1);
6110 }
6111
6112 if ((increment == 0) && (increment_max_chgd == 1))
6113 {
6114 log_error ("ERROR: increment-max is only supported together with increment switch");
6115
6116 return (-1);
6117 }
6118
6119 if (rp_files_cnt && rp_gen)
6120 {
6121 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6122
6123 return (-1);
6124 }
6125
6126 if (rp_files_cnt || rp_gen)
6127 {
6128 if (attack_mode != ATTACK_MODE_STRAIGHT)
6129 {
6130 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6131
6132 return (-1);
6133 }
6134 }
6135
6136 if (rp_gen_func_min > rp_gen_func_max)
6137 {
6138 log_error ("ERROR: Invalid rp-gen-func-min specified");
6139
6140 return (-1);
6141 }
6142
6143 if (kernel_accel_chgd == 1)
6144 {
6145 if (kernel_accel < 1)
6146 {
6147 log_error ("ERROR: Invalid kernel-accel specified");
6148
6149 return (-1);
6150 }
6151
6152 if (kernel_accel > 1024)
6153 {
6154 log_error ("ERROR: Invalid kernel-accel specified");
6155
6156 return (-1);
6157 }
6158 }
6159
6160 if (kernel_loops_chgd == 1)
6161 {
6162 if (kernel_loops < 1)
6163 {
6164 log_error ("ERROR: Invalid kernel-loops specified");
6165
6166 return (-1);
6167 }
6168
6169 if (kernel_loops > 1024)
6170 {
6171 log_error ("ERROR: Invalid kernel-loops specified");
6172
6173 return (-1);
6174 }
6175 }
6176
6177 if ((workload_profile < 1) || (workload_profile > 3))
6178 {
6179 log_error ("ERROR: workload-profile %i not available", workload_profile);
6180
6181 return (-1);
6182 }
6183
6184 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6185 {
6186 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6187
6188 return (-1);
6189 }
6190
6191 if (show == 1 || left == 1)
6192 {
6193 attack_mode = ATTACK_MODE_NONE;
6194
6195 if (remove == 1)
6196 {
6197 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6198
6199 return (-1);
6200 }
6201
6202 if (potfile_disable == 1)
6203 {
6204 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6205
6206 return (-1);
6207 }
6208 }
6209
6210 uint attack_kern = ATTACK_KERN_NONE;
6211
6212 switch (attack_mode)
6213 {
6214 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6215 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6216 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6217 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6218 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6219 }
6220
6221 if (benchmark == 0)
6222 {
6223 if (keyspace == 1)
6224 {
6225 int num_additional_params = 1;
6226
6227 if (attack_kern == ATTACK_KERN_COMBI)
6228 {
6229 num_additional_params = 2;
6230 }
6231
6232 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6233
6234 if (keyspace_wordlist_specified == 0) optind--;
6235 }
6236
6237 if (attack_kern == ATTACK_KERN_NONE)
6238 {
6239 if ((optind + 1) != myargc)
6240 {
6241 usage_mini_print (myargv[0]);
6242
6243 return (-1);
6244 }
6245 }
6246 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6247 {
6248 if ((optind + 1) > myargc)
6249 {
6250 usage_mini_print (myargv[0]);
6251
6252 return (-1);
6253 }
6254 }
6255 else if (attack_kern == ATTACK_KERN_COMBI)
6256 {
6257 if ((optind + 3) != myargc)
6258 {
6259 usage_mini_print (myargv[0]);
6260
6261 return (-1);
6262 }
6263 }
6264 else if (attack_kern == ATTACK_KERN_BF)
6265 {
6266 if ((optind + 1) > myargc)
6267 {
6268 usage_mini_print (myargv[0]);
6269
6270 return (-1);
6271 }
6272 }
6273 else
6274 {
6275 usage_mini_print (myargv[0]);
6276
6277 return (-1);
6278 }
6279 }
6280 else
6281 {
6282 if (myargv[optind] != 0)
6283 {
6284 log_error ("ERROR: Invalid argument for benchmark mode specified");
6285
6286 return (-1);
6287 }
6288
6289 if (attack_mode_chgd == 1)
6290 {
6291 if (attack_mode != ATTACK_MODE_BF)
6292 {
6293 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6294
6295 return (-1);
6296 }
6297 }
6298 }
6299
6300 if (skip != 0 && limit != 0)
6301 {
6302 limit += skip;
6303 }
6304
6305 if (keyspace == 1)
6306 {
6307 if (show == 1)
6308 {
6309 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6310
6311 return (-1);
6312 }
6313 else if (left == 1)
6314 {
6315 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6316
6317 return (-1);
6318 }
6319
6320 potfile_disable = 1;
6321
6322 restore_disable = 1;
6323
6324 restore = 0;
6325
6326 weak_hash_threshold = 0;
6327
6328 quiet = 1;
6329 }
6330
6331 if (remove_timer_chgd == 1)
6332 {
6333 if (remove == 0)
6334 {
6335 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6336
6337 return (-1);
6338 }
6339
6340 if (remove_timer < 1)
6341 {
6342 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6343
6344 return (-1);
6345 }
6346 }
6347
6348 if (loopback == 1)
6349 {
6350 if (attack_mode == ATTACK_MODE_STRAIGHT)
6351 {
6352 if ((rp_files_cnt == 0) && (rp_gen == 0))
6353 {
6354 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6355
6356 return (-1);
6357 }
6358 }
6359 else
6360 {
6361 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6362
6363 return (-1);
6364 }
6365 }
6366
6367 if (debug_mode > 0)
6368 {
6369 if (attack_mode != ATTACK_MODE_STRAIGHT)
6370 {
6371 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6372
6373 return (-1);
6374 }
6375
6376 if ((rp_files_cnt == 0) && (rp_gen == 0))
6377 {
6378 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6379
6380 return (-1);
6381 }
6382 }
6383
6384 if (debug_mode > 4)
6385 {
6386 log_error ("ERROR: Invalid debug-mode specified");
6387
6388 return (-1);
6389 }
6390
6391 if (debug_file != NULL)
6392 {
6393 if (debug_mode < 1)
6394 {
6395 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6396
6397 return (-1);
6398 }
6399 }
6400
6401 if (induction_dir != NULL)
6402 {
6403 if (attack_mode == ATTACK_MODE_BF)
6404 {
6405 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6406
6407 return (-1);
6408 }
6409 }
6410
6411 if (attack_mode != ATTACK_MODE_STRAIGHT)
6412 {
6413 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6414 {
6415 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6416
6417 return (-1);
6418 }
6419
6420 weak_hash_threshold = 0;
6421 }
6422
6423 /**
6424 * induction directory
6425 */
6426
6427 char *induction_directory = NULL;
6428
6429 if (attack_mode != ATTACK_MODE_BF)
6430 {
6431 if (induction_dir == NULL)
6432 {
6433 induction_directory = (char *) mymalloc (session_size);
6434
6435 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6436
6437 // create induction folder if it does not already exist
6438
6439 if (keyspace == 0)
6440 {
6441 if (rmdir (induction_directory) == -1)
6442 {
6443 if (errno == ENOENT)
6444 {
6445 // good, we can ignore
6446 }
6447 else if (errno == ENOTEMPTY)
6448 {
6449 char *induction_directory_mv = (char *) mymalloc (session_size);
6450
6451 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6452
6453 if (rename (induction_directory, induction_directory_mv) != 0)
6454 {
6455 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6456
6457 return (-1);
6458 }
6459 }
6460 else
6461 {
6462 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6463
6464 return (-1);
6465 }
6466 }
6467
6468 if (mkdir (induction_directory, 0700) == -1)
6469 {
6470 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6471
6472 return (-1);
6473 }
6474 }
6475 }
6476 else
6477 {
6478 induction_directory = induction_dir;
6479 }
6480 }
6481
6482 data.induction_directory = induction_directory;
6483
6484 /**
6485 * loopback
6486 */
6487
6488 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6489
6490 char *loopback_file = (char *) mymalloc (loopback_size);
6491
6492 /**
6493 * tuning db
6494 */
6495
6496 char tuning_db_file[256] = { 0 };
6497
6498 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6499
6500 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6501
6502 /**
6503 * outfile-check directory
6504 */
6505
6506 char *outfile_check_directory = NULL;
6507
6508 if (outfile_check_dir == NULL)
6509 {
6510 outfile_check_directory = (char *) mymalloc (session_size);
6511
6512 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6513 }
6514 else
6515 {
6516 outfile_check_directory = outfile_check_dir;
6517 }
6518
6519 data.outfile_check_directory = outfile_check_directory;
6520
6521 if (keyspace == 0)
6522 {
6523 struct stat outfile_check_stat;
6524
6525 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6526 {
6527 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6528
6529 if (is_dir == 0)
6530 {
6531 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6532
6533 return (-1);
6534 }
6535 }
6536 else if (outfile_check_dir == NULL)
6537 {
6538 if (mkdir (outfile_check_directory, 0700) == -1)
6539 {
6540 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6541
6542 return (-1);
6543 }
6544 }
6545 }
6546
6547 /**
6548 * special other stuff
6549 */
6550
6551 if (hash_mode == 9710)
6552 {
6553 outfile_format = 5;
6554 outfile_format_chgd = 1;
6555 }
6556
6557 if (hash_mode == 9810)
6558 {
6559 outfile_format = 5;
6560 outfile_format_chgd = 1;
6561 }
6562
6563 if (hash_mode == 10410)
6564 {
6565 outfile_format = 5;
6566 outfile_format_chgd = 1;
6567 }
6568
6569 /**
6570 * store stuff
6571 */
6572
6573 data.hash_mode = hash_mode;
6574 data.restore = restore;
6575 data.restore_timer = restore_timer;
6576 data.restore_disable = restore_disable;
6577 data.status = status;
6578 data.status_timer = status_timer;
6579 data.status_automat = status_automat;
6580 data.loopback = loopback;
6581 data.runtime = runtime;
6582 data.remove = remove;
6583 data.remove_timer = remove_timer;
6584 data.debug_mode = debug_mode;
6585 data.debug_file = debug_file;
6586 data.username = username;
6587 data.quiet = quiet;
6588 data.outfile = outfile;
6589 data.outfile_format = outfile_format;
6590 data.outfile_autohex = outfile_autohex;
6591 data.hex_charset = hex_charset;
6592 data.hex_salt = hex_salt;
6593 data.hex_wordlist = hex_wordlist;
6594 data.separator = separator;
6595 data.rp_files = rp_files;
6596 data.rp_files_cnt = rp_files_cnt;
6597 data.rp_gen = rp_gen;
6598 data.rp_gen_seed = rp_gen_seed;
6599 data.force = force;
6600 data.benchmark = benchmark;
6601 data.benchmark_repeats = benchmark_repeats;
6602 data.skip = skip;
6603 data.limit = limit;
6604 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6605 data.powertune_enable = powertune_enable;
6606 #endif
6607 data.logfile_disable = logfile_disable;
6608 data.truecrypt_keyfiles = truecrypt_keyfiles;
6609 data.scrypt_tmto = scrypt_tmto;
6610 data.workload_profile = workload_profile;
6611
6612 /**
6613 * cpu affinity
6614 */
6615
6616 if (cpu_affinity)
6617 {
6618 set_cpu_affinity (cpu_affinity);
6619 }
6620
6621 if (rp_gen_seed_chgd == 0)
6622 {
6623 srand (proc_start);
6624 }
6625 else
6626 {
6627 srand (rp_gen_seed);
6628 }
6629
6630 /**
6631 * logfile init
6632 */
6633
6634 if (logfile_disable == 0)
6635 {
6636 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6637
6638 char *logfile = (char *) mymalloc (logfile_size);
6639
6640 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6641
6642 data.logfile = logfile;
6643
6644 char *topid = logfile_generate_topid ();
6645
6646 data.topid = topid;
6647 }
6648
6649 // logfile_append() checks for logfile_disable internally to make it easier from here
6650
6651 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6652 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6653 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6654 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6655 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6656 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6657 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6658 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6659 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6660 #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));
6661
6662 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6663 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6664 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6665 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6666 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6667 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6668 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6669 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6670
6671 logfile_top_msg ("START");
6672
6673 logfile_top_uint (attack_mode);
6674 logfile_top_uint (attack_kern);
6675 logfile_top_uint (benchmark);
6676 logfile_top_uint (benchmark_repeats);
6677 logfile_top_uint (bitmap_min);
6678 logfile_top_uint (bitmap_max);
6679 logfile_top_uint (debug_mode);
6680 logfile_top_uint (force);
6681 logfile_top_uint (kernel_accel);
6682 logfile_top_uint (kernel_loops);
6683 logfile_top_uint (gpu_temp_disable);
6684 #ifdef HAVE_HWMON
6685 logfile_top_uint (gpu_temp_abort);
6686 logfile_top_uint (gpu_temp_retain);
6687 #endif
6688 logfile_top_uint (hash_mode);
6689 logfile_top_uint (hex_charset);
6690 logfile_top_uint (hex_salt);
6691 logfile_top_uint (hex_wordlist);
6692 logfile_top_uint (increment);
6693 logfile_top_uint (increment_max);
6694 logfile_top_uint (increment_min);
6695 logfile_top_uint (keyspace);
6696 logfile_top_uint (left);
6697 logfile_top_uint (logfile_disable);
6698 logfile_top_uint (loopback);
6699 logfile_top_uint (markov_classic);
6700 logfile_top_uint (markov_disable);
6701 logfile_top_uint (markov_threshold);
6702 logfile_top_uint (outfile_autohex);
6703 logfile_top_uint (outfile_check_timer);
6704 logfile_top_uint (outfile_format);
6705 logfile_top_uint (potfile_disable);
6706 logfile_top_string (potfile_path);
6707 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6708 logfile_top_uint (powertune_enable);
6709 #endif
6710 logfile_top_uint (scrypt_tmto);
6711 logfile_top_uint (quiet);
6712 logfile_top_uint (remove);
6713 logfile_top_uint (remove_timer);
6714 logfile_top_uint (restore);
6715 logfile_top_uint (restore_disable);
6716 logfile_top_uint (restore_timer);
6717 logfile_top_uint (rp_gen);
6718 logfile_top_uint (rp_gen_func_max);
6719 logfile_top_uint (rp_gen_func_min);
6720 logfile_top_uint (rp_gen_seed);
6721 logfile_top_uint (runtime);
6722 logfile_top_uint (segment_size);
6723 logfile_top_uint (show);
6724 logfile_top_uint (status);
6725 logfile_top_uint (status_automat);
6726 logfile_top_uint (status_timer);
6727 logfile_top_uint (usage);
6728 logfile_top_uint (username);
6729 logfile_top_uint (version);
6730 logfile_top_uint (weak_hash_threshold);
6731 logfile_top_uint (workload_profile);
6732 logfile_top_uint64 (limit);
6733 logfile_top_uint64 (skip);
6734 logfile_top_char (separator);
6735 logfile_top_string (cpu_affinity);
6736 logfile_top_string (custom_charset_1);
6737 logfile_top_string (custom_charset_2);
6738 logfile_top_string (custom_charset_3);
6739 logfile_top_string (custom_charset_4);
6740 logfile_top_string (debug_file);
6741 logfile_top_string (opencl_devices);
6742 logfile_top_string (opencl_platforms);
6743 logfile_top_string (opencl_device_types);
6744 logfile_top_uint (opencl_vector_width);
6745 logfile_top_string (induction_dir);
6746 logfile_top_string (markov_hcstat);
6747 logfile_top_string (outfile);
6748 logfile_top_string (outfile_check_dir);
6749 logfile_top_string (rule_buf_l);
6750 logfile_top_string (rule_buf_r);
6751 logfile_top_string (session);
6752 logfile_top_string (truecrypt_keyfiles);
6753
6754 /**
6755 * Init OpenCL library loader
6756 */
6757
6758 if (keyspace == 0)
6759 {
6760 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6761
6762 ocl_init (ocl);
6763
6764 data.ocl = ocl;
6765 }
6766
6767 /**
6768 * OpenCL platform selection
6769 */
6770
6771 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6772
6773 /**
6774 * OpenCL device selection
6775 */
6776
6777 u32 devices_filter = setup_devices_filter (opencl_devices);
6778
6779 /**
6780 * OpenCL device type selection
6781 */
6782
6783 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6784
6785 /**
6786 * benchmark
6787 */
6788
6789 if (benchmark == 1)
6790 {
6791 /**
6792 * disable useless stuff for benchmark
6793 */
6794
6795 status_timer = 0;
6796 restore_timer = 0;
6797 restore_disable = 1;
6798 potfile_disable = 1;
6799 weak_hash_threshold = 0;
6800 gpu_temp_disable = 1;
6801
6802 data.status_timer = status_timer;
6803 data.restore_timer = restore_timer;
6804 data.restore_disable = restore_disable;
6805
6806 /**
6807 * force attack mode to be bruteforce
6808 */
6809
6810 attack_mode = ATTACK_MODE_BF;
6811 attack_kern = ATTACK_KERN_BF;
6812
6813 if (workload_profile_chgd == 0)
6814 {
6815 workload_profile = 3;
6816
6817 data.workload_profile = workload_profile;
6818 }
6819 }
6820
6821 /**
6822 * config
6823 */
6824
6825 uint hash_type = 0;
6826 uint salt_type = 0;
6827 uint attack_exec = 0;
6828 uint opts_type = 0;
6829 uint kern_type = 0;
6830 uint dgst_size = 0;
6831 uint esalt_size = 0;
6832 uint opti_type = 0;
6833 uint dgst_pos0 = -1;
6834 uint dgst_pos1 = -1;
6835 uint dgst_pos2 = -1;
6836 uint dgst_pos3 = -1;
6837
6838 int (*parse_func) (char *, uint, hash_t *);
6839 int (*sort_by_digest) (const void *, const void *);
6840
6841 uint algorithm_pos = 0;
6842 uint algorithm_max = 1;
6843
6844 uint *algorithms = default_benchmark_algorithms;
6845
6846 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6847
6848 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6849 {
6850 /*
6851 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6852 * the following algos are skipped entirely
6853 */
6854
6855 if (algorithm_pos > 0)
6856 {
6857 local_free (rd);
6858
6859 rd = init_restore (argc, argv);
6860
6861 data.rd = rd;
6862 }
6863
6864 /**
6865 * update hash_mode in case of multihash benchmark
6866 */
6867
6868 if (benchmark == 1)
6869 {
6870 if (hash_mode_chgd == 0)
6871 {
6872 hash_mode = algorithms[algorithm_pos];
6873
6874 data.hash_mode = hash_mode;
6875 }
6876
6877 quiet = 1;
6878
6879 data.quiet = quiet;
6880 }
6881
6882 switch (hash_mode)
6883 {
6884 case 0: hash_type = HASH_TYPE_MD5;
6885 salt_type = SALT_TYPE_NONE;
6886 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6887 opts_type = OPTS_TYPE_PT_GENERATE_LE
6888 | OPTS_TYPE_PT_ADD80
6889 | OPTS_TYPE_PT_ADDBITS14;
6890 kern_type = KERN_TYPE_MD5;
6891 dgst_size = DGST_SIZE_4_4;
6892 parse_func = md5_parse_hash;
6893 sort_by_digest = sort_by_digest_4_4;
6894 opti_type = OPTI_TYPE_ZERO_BYTE
6895 | OPTI_TYPE_PRECOMPUTE_INIT
6896 | OPTI_TYPE_PRECOMPUTE_MERKLE
6897 | OPTI_TYPE_MEET_IN_MIDDLE
6898 | OPTI_TYPE_EARLY_SKIP
6899 | OPTI_TYPE_NOT_ITERATED
6900 | OPTI_TYPE_NOT_SALTED
6901 | OPTI_TYPE_RAW_HASH;
6902 dgst_pos0 = 0;
6903 dgst_pos1 = 3;
6904 dgst_pos2 = 2;
6905 dgst_pos3 = 1;
6906 break;
6907
6908 case 10: hash_type = HASH_TYPE_MD5;
6909 salt_type = SALT_TYPE_INTERN;
6910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6911 opts_type = OPTS_TYPE_PT_GENERATE_LE
6912 | OPTS_TYPE_ST_ADD80
6913 | OPTS_TYPE_ST_ADDBITS14;
6914 kern_type = KERN_TYPE_MD5_PWSLT;
6915 dgst_size = DGST_SIZE_4_4;
6916 parse_func = md5s_parse_hash;
6917 sort_by_digest = sort_by_digest_4_4;
6918 opti_type = OPTI_TYPE_ZERO_BYTE
6919 | OPTI_TYPE_PRECOMPUTE_INIT
6920 | OPTI_TYPE_PRECOMPUTE_MERKLE
6921 | OPTI_TYPE_MEET_IN_MIDDLE
6922 | OPTI_TYPE_EARLY_SKIP
6923 | OPTI_TYPE_NOT_ITERATED
6924 | OPTI_TYPE_APPENDED_SALT
6925 | OPTI_TYPE_RAW_HASH;
6926 dgst_pos0 = 0;
6927 dgst_pos1 = 3;
6928 dgst_pos2 = 2;
6929 dgst_pos3 = 1;
6930 break;
6931
6932 case 11: hash_type = HASH_TYPE_MD5;
6933 salt_type = SALT_TYPE_INTERN;
6934 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6935 opts_type = OPTS_TYPE_PT_GENERATE_LE
6936 | OPTS_TYPE_ST_ADD80
6937 | OPTS_TYPE_ST_ADDBITS14;
6938 kern_type = KERN_TYPE_MD5_PWSLT;
6939 dgst_size = DGST_SIZE_4_4;
6940 parse_func = joomla_parse_hash;
6941 sort_by_digest = sort_by_digest_4_4;
6942 opti_type = OPTI_TYPE_ZERO_BYTE
6943 | OPTI_TYPE_PRECOMPUTE_INIT
6944 | OPTI_TYPE_PRECOMPUTE_MERKLE
6945 | OPTI_TYPE_MEET_IN_MIDDLE
6946 | OPTI_TYPE_EARLY_SKIP
6947 | OPTI_TYPE_NOT_ITERATED
6948 | OPTI_TYPE_APPENDED_SALT
6949 | OPTI_TYPE_RAW_HASH;
6950 dgst_pos0 = 0;
6951 dgst_pos1 = 3;
6952 dgst_pos2 = 2;
6953 dgst_pos3 = 1;
6954 break;
6955
6956 case 12: hash_type = HASH_TYPE_MD5;
6957 salt_type = SALT_TYPE_INTERN;
6958 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6959 opts_type = OPTS_TYPE_PT_GENERATE_LE
6960 | OPTS_TYPE_ST_ADD80
6961 | OPTS_TYPE_ST_ADDBITS14;
6962 kern_type = KERN_TYPE_MD5_PWSLT;
6963 dgst_size = DGST_SIZE_4_4;
6964 parse_func = postgresql_parse_hash;
6965 sort_by_digest = sort_by_digest_4_4;
6966 opti_type = OPTI_TYPE_ZERO_BYTE
6967 | OPTI_TYPE_PRECOMPUTE_INIT
6968 | OPTI_TYPE_PRECOMPUTE_MERKLE
6969 | OPTI_TYPE_MEET_IN_MIDDLE
6970 | OPTI_TYPE_EARLY_SKIP
6971 | OPTI_TYPE_NOT_ITERATED
6972 | OPTI_TYPE_APPENDED_SALT
6973 | OPTI_TYPE_RAW_HASH;
6974 dgst_pos0 = 0;
6975 dgst_pos1 = 3;
6976 dgst_pos2 = 2;
6977 dgst_pos3 = 1;
6978 break;
6979
6980 case 20: hash_type = HASH_TYPE_MD5;
6981 salt_type = SALT_TYPE_INTERN;
6982 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6983 opts_type = OPTS_TYPE_PT_GENERATE_LE
6984 | OPTS_TYPE_PT_ADD80
6985 | OPTS_TYPE_PT_ADDBITS14;
6986 kern_type = KERN_TYPE_MD5_SLTPW;
6987 dgst_size = DGST_SIZE_4_4;
6988 parse_func = md5s_parse_hash;
6989 sort_by_digest = sort_by_digest_4_4;
6990 opti_type = OPTI_TYPE_ZERO_BYTE
6991 | OPTI_TYPE_PRECOMPUTE_INIT
6992 | OPTI_TYPE_PRECOMPUTE_MERKLE
6993 | OPTI_TYPE_EARLY_SKIP
6994 | OPTI_TYPE_NOT_ITERATED
6995 | OPTI_TYPE_PREPENDED_SALT
6996 | OPTI_TYPE_RAW_HASH;
6997 dgst_pos0 = 0;
6998 dgst_pos1 = 3;
6999 dgst_pos2 = 2;
7000 dgst_pos3 = 1;
7001 break;
7002
7003 case 21: hash_type = HASH_TYPE_MD5;
7004 salt_type = SALT_TYPE_INTERN;
7005 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7006 opts_type = OPTS_TYPE_PT_GENERATE_LE
7007 | OPTS_TYPE_PT_ADD80
7008 | OPTS_TYPE_PT_ADDBITS14;
7009 kern_type = KERN_TYPE_MD5_SLTPW;
7010 dgst_size = DGST_SIZE_4_4;
7011 parse_func = osc_parse_hash;
7012 sort_by_digest = sort_by_digest_4_4;
7013 opti_type = OPTI_TYPE_ZERO_BYTE
7014 | OPTI_TYPE_PRECOMPUTE_INIT
7015 | OPTI_TYPE_PRECOMPUTE_MERKLE
7016 | OPTI_TYPE_EARLY_SKIP
7017 | OPTI_TYPE_NOT_ITERATED
7018 | OPTI_TYPE_PREPENDED_SALT
7019 | OPTI_TYPE_RAW_HASH;
7020 dgst_pos0 = 0;
7021 dgst_pos1 = 3;
7022 dgst_pos2 = 2;
7023 dgst_pos3 = 1;
7024 break;
7025
7026 case 22: hash_type = HASH_TYPE_MD5;
7027 salt_type = SALT_TYPE_EMBEDDED;
7028 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7029 opts_type = OPTS_TYPE_PT_GENERATE_LE
7030 | OPTS_TYPE_PT_ADD80
7031 | OPTS_TYPE_PT_ADDBITS14;
7032 kern_type = KERN_TYPE_MD5_SLTPW;
7033 dgst_size = DGST_SIZE_4_4;
7034 parse_func = netscreen_parse_hash;
7035 sort_by_digest = sort_by_digest_4_4;
7036 opti_type = OPTI_TYPE_ZERO_BYTE
7037 | OPTI_TYPE_PRECOMPUTE_INIT
7038 | OPTI_TYPE_PRECOMPUTE_MERKLE
7039 | OPTI_TYPE_EARLY_SKIP
7040 | OPTI_TYPE_NOT_ITERATED
7041 | OPTI_TYPE_PREPENDED_SALT
7042 | OPTI_TYPE_RAW_HASH;
7043 dgst_pos0 = 0;
7044 dgst_pos1 = 3;
7045 dgst_pos2 = 2;
7046 dgst_pos3 = 1;
7047 break;
7048
7049 case 23: hash_type = HASH_TYPE_MD5;
7050 salt_type = SALT_TYPE_EMBEDDED;
7051 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7052 opts_type = OPTS_TYPE_PT_GENERATE_LE
7053 | OPTS_TYPE_PT_ADD80
7054 | OPTS_TYPE_PT_ADDBITS14;
7055 kern_type = KERN_TYPE_MD5_SLTPW;
7056 dgst_size = DGST_SIZE_4_4;
7057 parse_func = skype_parse_hash;
7058 sort_by_digest = sort_by_digest_4_4;
7059 opti_type = OPTI_TYPE_ZERO_BYTE
7060 | OPTI_TYPE_PRECOMPUTE_INIT
7061 | OPTI_TYPE_PRECOMPUTE_MERKLE
7062 | OPTI_TYPE_EARLY_SKIP
7063 | OPTI_TYPE_NOT_ITERATED
7064 | OPTI_TYPE_PREPENDED_SALT
7065 | OPTI_TYPE_RAW_HASH;
7066 dgst_pos0 = 0;
7067 dgst_pos1 = 3;
7068 dgst_pos2 = 2;
7069 dgst_pos3 = 1;
7070 break;
7071
7072 case 30: hash_type = HASH_TYPE_MD5;
7073 salt_type = SALT_TYPE_INTERN;
7074 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7075 opts_type = OPTS_TYPE_PT_GENERATE_LE
7076 | OPTS_TYPE_PT_UNICODE
7077 | OPTS_TYPE_ST_ADD80
7078 | OPTS_TYPE_ST_ADDBITS14;
7079 kern_type = KERN_TYPE_MD5_PWUSLT;
7080 dgst_size = DGST_SIZE_4_4;
7081 parse_func = md5s_parse_hash;
7082 sort_by_digest = sort_by_digest_4_4;
7083 opti_type = OPTI_TYPE_ZERO_BYTE
7084 | OPTI_TYPE_PRECOMPUTE_INIT
7085 | OPTI_TYPE_PRECOMPUTE_MERKLE
7086 | OPTI_TYPE_MEET_IN_MIDDLE
7087 | OPTI_TYPE_EARLY_SKIP
7088 | OPTI_TYPE_NOT_ITERATED
7089 | OPTI_TYPE_APPENDED_SALT
7090 | OPTI_TYPE_RAW_HASH;
7091 dgst_pos0 = 0;
7092 dgst_pos1 = 3;
7093 dgst_pos2 = 2;
7094 dgst_pos3 = 1;
7095 break;
7096
7097 case 40: hash_type = HASH_TYPE_MD5;
7098 salt_type = SALT_TYPE_INTERN;
7099 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7100 opts_type = OPTS_TYPE_PT_GENERATE_LE
7101 | OPTS_TYPE_PT_ADD80
7102 | OPTS_TYPE_PT_ADDBITS14
7103 | OPTS_TYPE_PT_UNICODE;
7104 kern_type = KERN_TYPE_MD5_SLTPWU;
7105 dgst_size = DGST_SIZE_4_4;
7106 parse_func = md5s_parse_hash;
7107 sort_by_digest = sort_by_digest_4_4;
7108 opti_type = OPTI_TYPE_ZERO_BYTE
7109 | OPTI_TYPE_PRECOMPUTE_INIT
7110 | OPTI_TYPE_PRECOMPUTE_MERKLE
7111 | OPTI_TYPE_EARLY_SKIP
7112 | OPTI_TYPE_NOT_ITERATED
7113 | OPTI_TYPE_PREPENDED_SALT
7114 | OPTI_TYPE_RAW_HASH;
7115 dgst_pos0 = 0;
7116 dgst_pos1 = 3;
7117 dgst_pos2 = 2;
7118 dgst_pos3 = 1;
7119 break;
7120
7121 case 50: hash_type = HASH_TYPE_MD5;
7122 salt_type = SALT_TYPE_INTERN;
7123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7124 opts_type = OPTS_TYPE_PT_GENERATE_LE
7125 | OPTS_TYPE_ST_ADD80
7126 | OPTS_TYPE_ST_ADDBITS14;
7127 kern_type = KERN_TYPE_HMACMD5_PW;
7128 dgst_size = DGST_SIZE_4_4;
7129 parse_func = hmacmd5_parse_hash;
7130 sort_by_digest = sort_by_digest_4_4;
7131 opti_type = OPTI_TYPE_ZERO_BYTE
7132 | OPTI_TYPE_NOT_ITERATED;
7133 dgst_pos0 = 0;
7134 dgst_pos1 = 3;
7135 dgst_pos2 = 2;
7136 dgst_pos3 = 1;
7137 break;
7138
7139 case 60: hash_type = HASH_TYPE_MD5;
7140 salt_type = SALT_TYPE_INTERN;
7141 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7142 opts_type = OPTS_TYPE_PT_GENERATE_LE
7143 | OPTS_TYPE_PT_ADD80
7144 | OPTS_TYPE_PT_ADDBITS14;
7145 kern_type = KERN_TYPE_HMACMD5_SLT;
7146 dgst_size = DGST_SIZE_4_4;
7147 parse_func = hmacmd5_parse_hash;
7148 sort_by_digest = sort_by_digest_4_4;
7149 opti_type = OPTI_TYPE_ZERO_BYTE
7150 | OPTI_TYPE_NOT_ITERATED;
7151 dgst_pos0 = 0;
7152 dgst_pos1 = 3;
7153 dgst_pos2 = 2;
7154 dgst_pos3 = 1;
7155 break;
7156
7157 case 100: hash_type = HASH_TYPE_SHA1;
7158 salt_type = SALT_TYPE_NONE;
7159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7160 opts_type = OPTS_TYPE_PT_GENERATE_BE
7161 | OPTS_TYPE_PT_ADD80
7162 | OPTS_TYPE_PT_ADDBITS15;
7163 kern_type = KERN_TYPE_SHA1;
7164 dgst_size = DGST_SIZE_4_5;
7165 parse_func = sha1_parse_hash;
7166 sort_by_digest = sort_by_digest_4_5;
7167 opti_type = OPTI_TYPE_ZERO_BYTE
7168 | OPTI_TYPE_PRECOMPUTE_INIT
7169 | OPTI_TYPE_PRECOMPUTE_MERKLE
7170 | OPTI_TYPE_EARLY_SKIP
7171 | OPTI_TYPE_NOT_ITERATED
7172 | OPTI_TYPE_NOT_SALTED
7173 | OPTI_TYPE_RAW_HASH;
7174 dgst_pos0 = 3;
7175 dgst_pos1 = 4;
7176 dgst_pos2 = 2;
7177 dgst_pos3 = 1;
7178 break;
7179
7180 case 101: hash_type = HASH_TYPE_SHA1;
7181 salt_type = SALT_TYPE_NONE;
7182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7183 opts_type = OPTS_TYPE_PT_GENERATE_BE
7184 | OPTS_TYPE_PT_ADD80
7185 | OPTS_TYPE_PT_ADDBITS15;
7186 kern_type = KERN_TYPE_SHA1;
7187 dgst_size = DGST_SIZE_4_5;
7188 parse_func = sha1b64_parse_hash;
7189 sort_by_digest = sort_by_digest_4_5;
7190 opti_type = OPTI_TYPE_ZERO_BYTE
7191 | OPTI_TYPE_PRECOMPUTE_INIT
7192 | OPTI_TYPE_PRECOMPUTE_MERKLE
7193 | OPTI_TYPE_EARLY_SKIP
7194 | OPTI_TYPE_NOT_ITERATED
7195 | OPTI_TYPE_NOT_SALTED
7196 | OPTI_TYPE_RAW_HASH;
7197 dgst_pos0 = 3;
7198 dgst_pos1 = 4;
7199 dgst_pos2 = 2;
7200 dgst_pos3 = 1;
7201 break;
7202
7203 case 110: hash_type = HASH_TYPE_SHA1;
7204 salt_type = SALT_TYPE_INTERN;
7205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7206 opts_type = OPTS_TYPE_PT_GENERATE_BE
7207 | OPTS_TYPE_ST_ADD80
7208 | OPTS_TYPE_ST_ADDBITS15;
7209 kern_type = KERN_TYPE_SHA1_PWSLT;
7210 dgst_size = DGST_SIZE_4_5;
7211 parse_func = sha1s_parse_hash;
7212 sort_by_digest = sort_by_digest_4_5;
7213 opti_type = OPTI_TYPE_ZERO_BYTE
7214 | OPTI_TYPE_PRECOMPUTE_INIT
7215 | OPTI_TYPE_PRECOMPUTE_MERKLE
7216 | OPTI_TYPE_EARLY_SKIP
7217 | OPTI_TYPE_NOT_ITERATED
7218 | OPTI_TYPE_APPENDED_SALT
7219 | OPTI_TYPE_RAW_HASH;
7220 dgst_pos0 = 3;
7221 dgst_pos1 = 4;
7222 dgst_pos2 = 2;
7223 dgst_pos3 = 1;
7224 break;
7225
7226 case 111: hash_type = HASH_TYPE_SHA1;
7227 salt_type = SALT_TYPE_EMBEDDED;
7228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7229 opts_type = OPTS_TYPE_PT_GENERATE_BE
7230 | OPTS_TYPE_ST_ADD80
7231 | OPTS_TYPE_ST_ADDBITS15;
7232 kern_type = KERN_TYPE_SHA1_PWSLT;
7233 dgst_size = DGST_SIZE_4_5;
7234 parse_func = sha1b64s_parse_hash;
7235 sort_by_digest = sort_by_digest_4_5;
7236 opti_type = OPTI_TYPE_ZERO_BYTE
7237 | OPTI_TYPE_PRECOMPUTE_INIT
7238 | OPTI_TYPE_PRECOMPUTE_MERKLE
7239 | OPTI_TYPE_EARLY_SKIP
7240 | OPTI_TYPE_NOT_ITERATED
7241 | OPTI_TYPE_APPENDED_SALT
7242 | OPTI_TYPE_RAW_HASH;
7243 dgst_pos0 = 3;
7244 dgst_pos1 = 4;
7245 dgst_pos2 = 2;
7246 dgst_pos3 = 1;
7247 break;
7248
7249 case 112: hash_type = HASH_TYPE_SHA1;
7250 salt_type = SALT_TYPE_INTERN;
7251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7252 opts_type = OPTS_TYPE_PT_GENERATE_BE
7253 | OPTS_TYPE_ST_ADD80
7254 | OPTS_TYPE_ST_ADDBITS15
7255 | OPTS_TYPE_ST_HEX;
7256 kern_type = KERN_TYPE_SHA1_PWSLT;
7257 dgst_size = DGST_SIZE_4_5;
7258 parse_func = oracles_parse_hash;
7259 sort_by_digest = sort_by_digest_4_5;
7260 opti_type = OPTI_TYPE_ZERO_BYTE
7261 | OPTI_TYPE_PRECOMPUTE_INIT
7262 | OPTI_TYPE_PRECOMPUTE_MERKLE
7263 | OPTI_TYPE_EARLY_SKIP
7264 | OPTI_TYPE_NOT_ITERATED
7265 | OPTI_TYPE_APPENDED_SALT
7266 | OPTI_TYPE_RAW_HASH;
7267 dgst_pos0 = 3;
7268 dgst_pos1 = 4;
7269 dgst_pos2 = 2;
7270 dgst_pos3 = 1;
7271 break;
7272
7273 case 120: hash_type = HASH_TYPE_SHA1;
7274 salt_type = SALT_TYPE_INTERN;
7275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7276 opts_type = OPTS_TYPE_PT_GENERATE_BE
7277 | OPTS_TYPE_PT_ADD80
7278 | OPTS_TYPE_PT_ADDBITS15;
7279 kern_type = KERN_TYPE_SHA1_SLTPW;
7280 dgst_size = DGST_SIZE_4_5;
7281 parse_func = sha1s_parse_hash;
7282 sort_by_digest = sort_by_digest_4_5;
7283 opti_type = OPTI_TYPE_ZERO_BYTE
7284 | OPTI_TYPE_PRECOMPUTE_INIT
7285 | OPTI_TYPE_PRECOMPUTE_MERKLE
7286 | OPTI_TYPE_EARLY_SKIP
7287 | OPTI_TYPE_NOT_ITERATED
7288 | OPTI_TYPE_PREPENDED_SALT
7289 | OPTI_TYPE_RAW_HASH;
7290 dgst_pos0 = 3;
7291 dgst_pos1 = 4;
7292 dgst_pos2 = 2;
7293 dgst_pos3 = 1;
7294 break;
7295
7296 case 121: hash_type = HASH_TYPE_SHA1;
7297 salt_type = SALT_TYPE_INTERN;
7298 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7299 opts_type = OPTS_TYPE_PT_GENERATE_BE
7300 | OPTS_TYPE_PT_ADD80
7301 | OPTS_TYPE_PT_ADDBITS15
7302 | OPTS_TYPE_ST_LOWER;
7303 kern_type = KERN_TYPE_SHA1_SLTPW;
7304 dgst_size = DGST_SIZE_4_5;
7305 parse_func = smf_parse_hash;
7306 sort_by_digest = sort_by_digest_4_5;
7307 opti_type = OPTI_TYPE_ZERO_BYTE
7308 | OPTI_TYPE_PRECOMPUTE_INIT
7309 | OPTI_TYPE_PRECOMPUTE_MERKLE
7310 | OPTI_TYPE_EARLY_SKIP
7311 | OPTI_TYPE_NOT_ITERATED
7312 | OPTI_TYPE_PREPENDED_SALT
7313 | OPTI_TYPE_RAW_HASH;
7314 dgst_pos0 = 3;
7315 dgst_pos1 = 4;
7316 dgst_pos2 = 2;
7317 dgst_pos3 = 1;
7318 break;
7319
7320 case 122: hash_type = HASH_TYPE_SHA1;
7321 salt_type = SALT_TYPE_EMBEDDED;
7322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7323 opts_type = OPTS_TYPE_PT_GENERATE_BE
7324 | OPTS_TYPE_PT_ADD80
7325 | OPTS_TYPE_PT_ADDBITS15
7326 | OPTS_TYPE_ST_HEX;
7327 kern_type = KERN_TYPE_SHA1_SLTPW;
7328 dgst_size = DGST_SIZE_4_5;
7329 parse_func = osx1_parse_hash;
7330 sort_by_digest = sort_by_digest_4_5;
7331 opti_type = OPTI_TYPE_ZERO_BYTE
7332 | OPTI_TYPE_PRECOMPUTE_INIT
7333 | OPTI_TYPE_PRECOMPUTE_MERKLE
7334 | OPTI_TYPE_EARLY_SKIP
7335 | OPTI_TYPE_NOT_ITERATED
7336 | OPTI_TYPE_PREPENDED_SALT
7337 | OPTI_TYPE_RAW_HASH;
7338 dgst_pos0 = 3;
7339 dgst_pos1 = 4;
7340 dgst_pos2 = 2;
7341 dgst_pos3 = 1;
7342 break;
7343
7344 case 124: hash_type = HASH_TYPE_SHA1;
7345 salt_type = SALT_TYPE_EMBEDDED;
7346 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7347 opts_type = OPTS_TYPE_PT_GENERATE_BE
7348 | OPTS_TYPE_PT_ADD80
7349 | OPTS_TYPE_PT_ADDBITS15;
7350 kern_type = KERN_TYPE_SHA1_SLTPW;
7351 dgst_size = DGST_SIZE_4_5;
7352 parse_func = djangosha1_parse_hash;
7353 sort_by_digest = sort_by_digest_4_5;
7354 opti_type = OPTI_TYPE_ZERO_BYTE
7355 | OPTI_TYPE_PRECOMPUTE_INIT
7356 | OPTI_TYPE_PRECOMPUTE_MERKLE
7357 | OPTI_TYPE_EARLY_SKIP
7358 | OPTI_TYPE_NOT_ITERATED
7359 | OPTI_TYPE_PREPENDED_SALT
7360 | OPTI_TYPE_RAW_HASH;
7361 dgst_pos0 = 3;
7362 dgst_pos1 = 4;
7363 dgst_pos2 = 2;
7364 dgst_pos3 = 1;
7365 break;
7366
7367 case 125: hash_type = HASH_TYPE_SHA1;
7368 salt_type = SALT_TYPE_EMBEDDED;
7369 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7370 opts_type = OPTS_TYPE_PT_GENERATE_BE
7371 | OPTS_TYPE_PT_ADD80
7372 | OPTS_TYPE_PT_ADDBITS15
7373 | OPTS_TYPE_ST_HEX;
7374 kern_type = KERN_TYPE_SHA1_SLTPW;
7375 dgst_size = DGST_SIZE_4_5;
7376 parse_func = arubaos_parse_hash;
7377 sort_by_digest = sort_by_digest_4_5;
7378 opti_type = OPTI_TYPE_ZERO_BYTE
7379 | OPTI_TYPE_PRECOMPUTE_INIT
7380 | OPTI_TYPE_PRECOMPUTE_MERKLE
7381 | OPTI_TYPE_EARLY_SKIP
7382 | OPTI_TYPE_NOT_ITERATED
7383 | OPTI_TYPE_PREPENDED_SALT
7384 | OPTI_TYPE_RAW_HASH;
7385 dgst_pos0 = 3;
7386 dgst_pos1 = 4;
7387 dgst_pos2 = 2;
7388 dgst_pos3 = 1;
7389 break;
7390
7391 case 130: hash_type = HASH_TYPE_SHA1;
7392 salt_type = SALT_TYPE_INTERN;
7393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7394 opts_type = OPTS_TYPE_PT_GENERATE_BE
7395 | OPTS_TYPE_PT_UNICODE
7396 | OPTS_TYPE_ST_ADD80
7397 | OPTS_TYPE_ST_ADDBITS15;
7398 kern_type = KERN_TYPE_SHA1_PWUSLT;
7399 dgst_size = DGST_SIZE_4_5;
7400 parse_func = sha1s_parse_hash;
7401 sort_by_digest = sort_by_digest_4_5;
7402 opti_type = OPTI_TYPE_ZERO_BYTE
7403 | OPTI_TYPE_PRECOMPUTE_INIT
7404 | OPTI_TYPE_PRECOMPUTE_MERKLE
7405 | OPTI_TYPE_EARLY_SKIP
7406 | OPTI_TYPE_NOT_ITERATED
7407 | OPTI_TYPE_APPENDED_SALT
7408 | OPTI_TYPE_RAW_HASH;
7409 dgst_pos0 = 3;
7410 dgst_pos1 = 4;
7411 dgst_pos2 = 2;
7412 dgst_pos3 = 1;
7413 break;
7414
7415 case 131: hash_type = HASH_TYPE_SHA1;
7416 salt_type = SALT_TYPE_EMBEDDED;
7417 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7418 opts_type = OPTS_TYPE_PT_GENERATE_BE
7419 | OPTS_TYPE_PT_UNICODE
7420 | OPTS_TYPE_PT_UPPER
7421 | OPTS_TYPE_ST_ADD80
7422 | OPTS_TYPE_ST_ADDBITS15
7423 | OPTS_TYPE_ST_HEX;
7424 kern_type = KERN_TYPE_SHA1_PWUSLT;
7425 dgst_size = DGST_SIZE_4_5;
7426 parse_func = mssql2000_parse_hash;
7427 sort_by_digest = sort_by_digest_4_5;
7428 opti_type = OPTI_TYPE_ZERO_BYTE
7429 | OPTI_TYPE_PRECOMPUTE_INIT
7430 | OPTI_TYPE_PRECOMPUTE_MERKLE
7431 | OPTI_TYPE_EARLY_SKIP
7432 | OPTI_TYPE_NOT_ITERATED
7433 | OPTI_TYPE_APPENDED_SALT
7434 | OPTI_TYPE_RAW_HASH;
7435 dgst_pos0 = 3;
7436 dgst_pos1 = 4;
7437 dgst_pos2 = 2;
7438 dgst_pos3 = 1;
7439 break;
7440
7441 case 132: hash_type = HASH_TYPE_SHA1;
7442 salt_type = SALT_TYPE_EMBEDDED;
7443 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7444 opts_type = OPTS_TYPE_PT_GENERATE_BE
7445 | OPTS_TYPE_PT_UNICODE
7446 | OPTS_TYPE_ST_ADD80
7447 | OPTS_TYPE_ST_ADDBITS15
7448 | OPTS_TYPE_ST_HEX;
7449 kern_type = KERN_TYPE_SHA1_PWUSLT;
7450 dgst_size = DGST_SIZE_4_5;
7451 parse_func = mssql2005_parse_hash;
7452 sort_by_digest = sort_by_digest_4_5;
7453 opti_type = OPTI_TYPE_ZERO_BYTE
7454 | OPTI_TYPE_PRECOMPUTE_INIT
7455 | OPTI_TYPE_PRECOMPUTE_MERKLE
7456 | OPTI_TYPE_EARLY_SKIP
7457 | OPTI_TYPE_NOT_ITERATED
7458 | OPTI_TYPE_APPENDED_SALT
7459 | OPTI_TYPE_RAW_HASH;
7460 dgst_pos0 = 3;
7461 dgst_pos1 = 4;
7462 dgst_pos2 = 2;
7463 dgst_pos3 = 1;
7464 break;
7465
7466 case 133: hash_type = HASH_TYPE_SHA1;
7467 salt_type = SALT_TYPE_EMBEDDED;
7468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7469 opts_type = OPTS_TYPE_PT_GENERATE_BE
7470 | OPTS_TYPE_PT_UNICODE
7471 | OPTS_TYPE_ST_ADD80
7472 | OPTS_TYPE_ST_ADDBITS15;
7473 kern_type = KERN_TYPE_SHA1_PWUSLT;
7474 dgst_size = DGST_SIZE_4_5;
7475 parse_func = peoplesoft_parse_hash;
7476 sort_by_digest = sort_by_digest_4_5;
7477 opti_type = OPTI_TYPE_ZERO_BYTE
7478 | OPTI_TYPE_PRECOMPUTE_INIT
7479 | OPTI_TYPE_PRECOMPUTE_MERKLE
7480 | OPTI_TYPE_EARLY_SKIP
7481 | OPTI_TYPE_NOT_ITERATED
7482 | OPTI_TYPE_APPENDED_SALT
7483 | OPTI_TYPE_RAW_HASH;
7484 dgst_pos0 = 3;
7485 dgst_pos1 = 4;
7486 dgst_pos2 = 2;
7487 dgst_pos3 = 1;
7488 break;
7489
7490 case 140: hash_type = HASH_TYPE_SHA1;
7491 salt_type = SALT_TYPE_INTERN;
7492 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7493 opts_type = OPTS_TYPE_PT_GENERATE_BE
7494 | OPTS_TYPE_PT_ADD80
7495 | OPTS_TYPE_PT_ADDBITS15
7496 | OPTS_TYPE_PT_UNICODE;
7497 kern_type = KERN_TYPE_SHA1_SLTPWU;
7498 dgst_size = DGST_SIZE_4_5;
7499 parse_func = sha1s_parse_hash;
7500 sort_by_digest = sort_by_digest_4_5;
7501 opti_type = OPTI_TYPE_ZERO_BYTE
7502 | OPTI_TYPE_PRECOMPUTE_INIT
7503 | OPTI_TYPE_PRECOMPUTE_MERKLE
7504 | OPTI_TYPE_EARLY_SKIP
7505 | OPTI_TYPE_NOT_ITERATED
7506 | OPTI_TYPE_PREPENDED_SALT
7507 | OPTI_TYPE_RAW_HASH;
7508 dgst_pos0 = 3;
7509 dgst_pos1 = 4;
7510 dgst_pos2 = 2;
7511 dgst_pos3 = 1;
7512 break;
7513
7514 case 141: hash_type = HASH_TYPE_SHA1;
7515 salt_type = SALT_TYPE_EMBEDDED;
7516 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7517 opts_type = OPTS_TYPE_PT_GENERATE_BE
7518 | OPTS_TYPE_PT_ADD80
7519 | OPTS_TYPE_PT_ADDBITS15
7520 | OPTS_TYPE_PT_UNICODE
7521 | OPTS_TYPE_ST_BASE64;
7522 kern_type = KERN_TYPE_SHA1_SLTPWU;
7523 dgst_size = DGST_SIZE_4_5;
7524 parse_func = episerver_parse_hash;
7525 sort_by_digest = sort_by_digest_4_5;
7526 opti_type = OPTI_TYPE_ZERO_BYTE
7527 | OPTI_TYPE_PRECOMPUTE_INIT
7528 | OPTI_TYPE_PRECOMPUTE_MERKLE
7529 | OPTI_TYPE_EARLY_SKIP
7530 | OPTI_TYPE_NOT_ITERATED
7531 | OPTI_TYPE_PREPENDED_SALT
7532 | OPTI_TYPE_RAW_HASH;
7533 dgst_pos0 = 3;
7534 dgst_pos1 = 4;
7535 dgst_pos2 = 2;
7536 dgst_pos3 = 1;
7537 break;
7538
7539 case 150: hash_type = HASH_TYPE_SHA1;
7540 salt_type = SALT_TYPE_INTERN;
7541 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7542 opts_type = OPTS_TYPE_PT_GENERATE_BE
7543 | OPTS_TYPE_ST_ADD80
7544 | OPTS_TYPE_ST_ADDBITS15;
7545 kern_type = KERN_TYPE_HMACSHA1_PW;
7546 dgst_size = DGST_SIZE_4_5;
7547 parse_func = hmacsha1_parse_hash;
7548 sort_by_digest = sort_by_digest_4_5;
7549 opti_type = OPTI_TYPE_ZERO_BYTE
7550 | OPTI_TYPE_NOT_ITERATED;
7551 dgst_pos0 = 3;
7552 dgst_pos1 = 4;
7553 dgst_pos2 = 2;
7554 dgst_pos3 = 1;
7555 break;
7556
7557 case 160: hash_type = HASH_TYPE_SHA1;
7558 salt_type = SALT_TYPE_INTERN;
7559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7560 opts_type = OPTS_TYPE_PT_GENERATE_BE
7561 | OPTS_TYPE_PT_ADD80
7562 | OPTS_TYPE_PT_ADDBITS15;
7563 kern_type = KERN_TYPE_HMACSHA1_SLT;
7564 dgst_size = DGST_SIZE_4_5;
7565 parse_func = hmacsha1_parse_hash;
7566 sort_by_digest = sort_by_digest_4_5;
7567 opti_type = OPTI_TYPE_ZERO_BYTE
7568 | OPTI_TYPE_NOT_ITERATED;
7569 dgst_pos0 = 3;
7570 dgst_pos1 = 4;
7571 dgst_pos2 = 2;
7572 dgst_pos3 = 1;
7573 break;
7574
7575 case 190: hash_type = HASH_TYPE_SHA1;
7576 salt_type = SALT_TYPE_NONE;
7577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7578 opts_type = OPTS_TYPE_PT_GENERATE_BE
7579 | OPTS_TYPE_PT_ADD80
7580 | OPTS_TYPE_PT_ADDBITS15;
7581 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7582 dgst_size = DGST_SIZE_4_5;
7583 parse_func = sha1linkedin_parse_hash;
7584 sort_by_digest = sort_by_digest_4_5;
7585 opti_type = OPTI_TYPE_ZERO_BYTE
7586 | OPTI_TYPE_PRECOMPUTE_INIT
7587 | OPTI_TYPE_EARLY_SKIP
7588 | OPTI_TYPE_NOT_ITERATED
7589 | OPTI_TYPE_NOT_SALTED;
7590 dgst_pos0 = 0;
7591 dgst_pos1 = 4;
7592 dgst_pos2 = 3;
7593 dgst_pos3 = 2;
7594 break;
7595
7596 case 200: hash_type = HASH_TYPE_MYSQL;
7597 salt_type = SALT_TYPE_NONE;
7598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7599 opts_type = 0;
7600 kern_type = KERN_TYPE_MYSQL;
7601 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7602 parse_func = mysql323_parse_hash;
7603 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7604 opti_type = OPTI_TYPE_ZERO_BYTE;
7605 dgst_pos0 = 0;
7606 dgst_pos1 = 1;
7607 dgst_pos2 = 2;
7608 dgst_pos3 = 3;
7609 break;
7610
7611 case 300: hash_type = HASH_TYPE_SHA1;
7612 salt_type = SALT_TYPE_NONE;
7613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7614 opts_type = OPTS_TYPE_PT_GENERATE_BE
7615 | OPTS_TYPE_PT_ADD80
7616 | OPTS_TYPE_PT_ADDBITS15;
7617 kern_type = KERN_TYPE_MYSQL41;
7618 dgst_size = DGST_SIZE_4_5;
7619 parse_func = sha1_parse_hash;
7620 sort_by_digest = sort_by_digest_4_5;
7621 opti_type = OPTI_TYPE_ZERO_BYTE
7622 | OPTI_TYPE_PRECOMPUTE_INIT
7623 | OPTI_TYPE_PRECOMPUTE_MERKLE
7624 | OPTI_TYPE_EARLY_SKIP
7625 | OPTI_TYPE_NOT_ITERATED
7626 | OPTI_TYPE_NOT_SALTED;
7627 dgst_pos0 = 3;
7628 dgst_pos1 = 4;
7629 dgst_pos2 = 2;
7630 dgst_pos3 = 1;
7631 break;
7632
7633 case 400: hash_type = HASH_TYPE_MD5;
7634 salt_type = SALT_TYPE_EMBEDDED;
7635 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7636 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7637 kern_type = KERN_TYPE_PHPASS;
7638 dgst_size = DGST_SIZE_4_4;
7639 parse_func = phpass_parse_hash;
7640 sort_by_digest = sort_by_digest_4_4;
7641 opti_type = OPTI_TYPE_ZERO_BYTE
7642 | OPTI_TYPE_SLOW_HASH_SIMD;
7643 dgst_pos0 = 0;
7644 dgst_pos1 = 1;
7645 dgst_pos2 = 2;
7646 dgst_pos3 = 3;
7647 break;
7648
7649 case 500: hash_type = HASH_TYPE_MD5;
7650 salt_type = SALT_TYPE_EMBEDDED;
7651 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7652 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7653 kern_type = KERN_TYPE_MD5CRYPT;
7654 dgst_size = DGST_SIZE_4_4;
7655 parse_func = md5crypt_parse_hash;
7656 sort_by_digest = sort_by_digest_4_4;
7657 opti_type = OPTI_TYPE_ZERO_BYTE;
7658 dgst_pos0 = 0;
7659 dgst_pos1 = 1;
7660 dgst_pos2 = 2;
7661 dgst_pos3 = 3;
7662 break;
7663
7664 case 501: hash_type = HASH_TYPE_MD5;
7665 salt_type = SALT_TYPE_EMBEDDED;
7666 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7667 opts_type = OPTS_TYPE_PT_GENERATE_LE
7668 | OPTS_TYPE_HASH_COPY;
7669 kern_type = KERN_TYPE_MD5CRYPT;
7670 dgst_size = DGST_SIZE_4_4;
7671 parse_func = juniper_parse_hash;
7672 sort_by_digest = sort_by_digest_4_4;
7673 opti_type = OPTI_TYPE_ZERO_BYTE;
7674 dgst_pos0 = 0;
7675 dgst_pos1 = 1;
7676 dgst_pos2 = 2;
7677 dgst_pos3 = 3;
7678 break;
7679
7680 case 900: hash_type = HASH_TYPE_MD4;
7681 salt_type = SALT_TYPE_NONE;
7682 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7683 opts_type = OPTS_TYPE_PT_GENERATE_LE
7684 | OPTS_TYPE_PT_ADD80
7685 | OPTS_TYPE_PT_ADDBITS14;
7686 kern_type = KERN_TYPE_MD4;
7687 dgst_size = DGST_SIZE_4_4;
7688 parse_func = md4_parse_hash;
7689 sort_by_digest = sort_by_digest_4_4;
7690 opti_type = OPTI_TYPE_ZERO_BYTE
7691 | OPTI_TYPE_PRECOMPUTE_INIT
7692 | OPTI_TYPE_PRECOMPUTE_MERKLE
7693 | OPTI_TYPE_MEET_IN_MIDDLE
7694 | OPTI_TYPE_EARLY_SKIP
7695 | OPTI_TYPE_NOT_ITERATED
7696 | OPTI_TYPE_NOT_SALTED
7697 | OPTI_TYPE_RAW_HASH;
7698 dgst_pos0 = 0;
7699 dgst_pos1 = 3;
7700 dgst_pos2 = 2;
7701 dgst_pos3 = 1;
7702 break;
7703
7704 case 1000: hash_type = HASH_TYPE_MD4;
7705 salt_type = SALT_TYPE_NONE;
7706 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7707 opts_type = OPTS_TYPE_PT_GENERATE_LE
7708 | OPTS_TYPE_PT_ADD80
7709 | OPTS_TYPE_PT_ADDBITS14
7710 | OPTS_TYPE_PT_UNICODE;
7711 kern_type = KERN_TYPE_MD4_PWU;
7712 dgst_size = DGST_SIZE_4_4;
7713 parse_func = md4_parse_hash;
7714 sort_by_digest = sort_by_digest_4_4;
7715 opti_type = OPTI_TYPE_ZERO_BYTE
7716 | OPTI_TYPE_PRECOMPUTE_INIT
7717 | OPTI_TYPE_PRECOMPUTE_MERKLE
7718 | OPTI_TYPE_MEET_IN_MIDDLE
7719 | OPTI_TYPE_EARLY_SKIP
7720 | OPTI_TYPE_NOT_ITERATED
7721 | OPTI_TYPE_NOT_SALTED
7722 | OPTI_TYPE_RAW_HASH;
7723 dgst_pos0 = 0;
7724 dgst_pos1 = 3;
7725 dgst_pos2 = 2;
7726 dgst_pos3 = 1;
7727 break;
7728
7729 case 1100: hash_type = HASH_TYPE_MD4;
7730 salt_type = SALT_TYPE_INTERN;
7731 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7732 opts_type = OPTS_TYPE_PT_GENERATE_LE
7733 | OPTS_TYPE_PT_ADD80
7734 | OPTS_TYPE_PT_ADDBITS14
7735 | OPTS_TYPE_PT_UNICODE
7736 | OPTS_TYPE_ST_ADD80
7737 | OPTS_TYPE_ST_UNICODE
7738 | OPTS_TYPE_ST_LOWER;
7739 kern_type = KERN_TYPE_MD44_PWUSLT;
7740 dgst_size = DGST_SIZE_4_4;
7741 parse_func = dcc_parse_hash;
7742 sort_by_digest = sort_by_digest_4_4;
7743 opti_type = OPTI_TYPE_ZERO_BYTE
7744 | OPTI_TYPE_PRECOMPUTE_INIT
7745 | OPTI_TYPE_PRECOMPUTE_MERKLE
7746 | OPTI_TYPE_EARLY_SKIP
7747 | OPTI_TYPE_NOT_ITERATED;
7748 dgst_pos0 = 0;
7749 dgst_pos1 = 3;
7750 dgst_pos2 = 2;
7751 dgst_pos3 = 1;
7752 break;
7753
7754 case 1400: hash_type = HASH_TYPE_SHA256;
7755 salt_type = SALT_TYPE_NONE;
7756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7757 opts_type = OPTS_TYPE_PT_GENERATE_BE
7758 | OPTS_TYPE_PT_ADD80
7759 | OPTS_TYPE_PT_ADDBITS15;
7760 kern_type = KERN_TYPE_SHA256;
7761 dgst_size = DGST_SIZE_4_8;
7762 parse_func = sha256_parse_hash;
7763 sort_by_digest = sort_by_digest_4_8;
7764 opti_type = OPTI_TYPE_ZERO_BYTE
7765 | OPTI_TYPE_PRECOMPUTE_INIT
7766 | OPTI_TYPE_PRECOMPUTE_MERKLE
7767 | OPTI_TYPE_EARLY_SKIP
7768 | OPTI_TYPE_NOT_ITERATED
7769 | OPTI_TYPE_NOT_SALTED
7770 | OPTI_TYPE_RAW_HASH;
7771 dgst_pos0 = 3;
7772 dgst_pos1 = 7;
7773 dgst_pos2 = 2;
7774 dgst_pos3 = 6;
7775 break;
7776
7777 case 1410: hash_type = HASH_TYPE_SHA256;
7778 salt_type = SALT_TYPE_INTERN;
7779 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7780 opts_type = OPTS_TYPE_PT_GENERATE_BE
7781 | OPTS_TYPE_ST_ADD80
7782 | OPTS_TYPE_ST_ADDBITS15;
7783 kern_type = KERN_TYPE_SHA256_PWSLT;
7784 dgst_size = DGST_SIZE_4_8;
7785 parse_func = sha256s_parse_hash;
7786 sort_by_digest = sort_by_digest_4_8;
7787 opti_type = OPTI_TYPE_ZERO_BYTE
7788 | OPTI_TYPE_PRECOMPUTE_INIT
7789 | OPTI_TYPE_PRECOMPUTE_MERKLE
7790 | OPTI_TYPE_EARLY_SKIP
7791 | OPTI_TYPE_NOT_ITERATED
7792 | OPTI_TYPE_APPENDED_SALT
7793 | OPTI_TYPE_RAW_HASH;
7794 dgst_pos0 = 3;
7795 dgst_pos1 = 7;
7796 dgst_pos2 = 2;
7797 dgst_pos3 = 6;
7798 break;
7799
7800 case 1420: hash_type = HASH_TYPE_SHA256;
7801 salt_type = SALT_TYPE_INTERN;
7802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7803 opts_type = OPTS_TYPE_PT_GENERATE_BE
7804 | OPTS_TYPE_PT_ADD80
7805 | OPTS_TYPE_PT_ADDBITS15;
7806 kern_type = KERN_TYPE_SHA256_SLTPW;
7807 dgst_size = DGST_SIZE_4_8;
7808 parse_func = sha256s_parse_hash;
7809 sort_by_digest = sort_by_digest_4_8;
7810 opti_type = OPTI_TYPE_ZERO_BYTE
7811 | OPTI_TYPE_PRECOMPUTE_INIT
7812 | OPTI_TYPE_PRECOMPUTE_MERKLE
7813 | OPTI_TYPE_EARLY_SKIP
7814 | OPTI_TYPE_NOT_ITERATED
7815 | OPTI_TYPE_PREPENDED_SALT
7816 | OPTI_TYPE_RAW_HASH;
7817 dgst_pos0 = 3;
7818 dgst_pos1 = 7;
7819 dgst_pos2 = 2;
7820 dgst_pos3 = 6;
7821 break;
7822
7823 case 1421: hash_type = HASH_TYPE_SHA256;
7824 salt_type = SALT_TYPE_EMBEDDED;
7825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7826 opts_type = OPTS_TYPE_PT_GENERATE_BE
7827 | OPTS_TYPE_PT_ADD80
7828 | OPTS_TYPE_PT_ADDBITS15;
7829 kern_type = KERN_TYPE_SHA256_SLTPW;
7830 dgst_size = DGST_SIZE_4_8;
7831 parse_func = hmailserver_parse_hash;
7832 sort_by_digest = sort_by_digest_4_8;
7833 opti_type = OPTI_TYPE_ZERO_BYTE
7834 | OPTI_TYPE_PRECOMPUTE_INIT
7835 | OPTI_TYPE_PRECOMPUTE_MERKLE
7836 | OPTI_TYPE_EARLY_SKIP
7837 | OPTI_TYPE_NOT_ITERATED
7838 | OPTI_TYPE_PREPENDED_SALT
7839 | OPTI_TYPE_RAW_HASH;
7840 dgst_pos0 = 3;
7841 dgst_pos1 = 7;
7842 dgst_pos2 = 2;
7843 dgst_pos3 = 6;
7844 break;
7845
7846 case 1430: hash_type = HASH_TYPE_SHA256;
7847 salt_type = SALT_TYPE_INTERN;
7848 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7849 opts_type = OPTS_TYPE_PT_GENERATE_BE
7850 | OPTS_TYPE_PT_UNICODE
7851 | OPTS_TYPE_ST_ADD80
7852 | OPTS_TYPE_ST_ADDBITS15;
7853 kern_type = KERN_TYPE_SHA256_PWUSLT;
7854 dgst_size = DGST_SIZE_4_8;
7855 parse_func = sha256s_parse_hash;
7856 sort_by_digest = sort_by_digest_4_8;
7857 opti_type = OPTI_TYPE_ZERO_BYTE
7858 | OPTI_TYPE_PRECOMPUTE_INIT
7859 | OPTI_TYPE_PRECOMPUTE_MERKLE
7860 | OPTI_TYPE_EARLY_SKIP
7861 | OPTI_TYPE_NOT_ITERATED
7862 | OPTI_TYPE_APPENDED_SALT
7863 | OPTI_TYPE_RAW_HASH;
7864 dgst_pos0 = 3;
7865 dgst_pos1 = 7;
7866 dgst_pos2 = 2;
7867 dgst_pos3 = 6;
7868 break;
7869
7870 case 1440: hash_type = HASH_TYPE_SHA256;
7871 salt_type = SALT_TYPE_INTERN;
7872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7873 opts_type = OPTS_TYPE_PT_GENERATE_BE
7874 | OPTS_TYPE_PT_ADD80
7875 | OPTS_TYPE_PT_ADDBITS15
7876 | OPTS_TYPE_PT_UNICODE;
7877 kern_type = KERN_TYPE_SHA256_SLTPWU;
7878 dgst_size = DGST_SIZE_4_8;
7879 parse_func = sha256s_parse_hash;
7880 sort_by_digest = sort_by_digest_4_8;
7881 opti_type = OPTI_TYPE_ZERO_BYTE
7882 | OPTI_TYPE_PRECOMPUTE_INIT
7883 | OPTI_TYPE_PRECOMPUTE_MERKLE
7884 | OPTI_TYPE_EARLY_SKIP
7885 | OPTI_TYPE_NOT_ITERATED
7886 | OPTI_TYPE_PREPENDED_SALT
7887 | OPTI_TYPE_RAW_HASH;
7888 dgst_pos0 = 3;
7889 dgst_pos1 = 7;
7890 dgst_pos2 = 2;
7891 dgst_pos3 = 6;
7892 break;
7893
7894 case 1441: hash_type = HASH_TYPE_SHA256;
7895 salt_type = SALT_TYPE_EMBEDDED;
7896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7897 opts_type = OPTS_TYPE_PT_GENERATE_BE
7898 | OPTS_TYPE_PT_ADD80
7899 | OPTS_TYPE_PT_ADDBITS15
7900 | OPTS_TYPE_PT_UNICODE
7901 | OPTS_TYPE_ST_BASE64;
7902 kern_type = KERN_TYPE_SHA256_SLTPWU;
7903 dgst_size = DGST_SIZE_4_8;
7904 parse_func = episerver4_parse_hash;
7905 sort_by_digest = sort_by_digest_4_8;
7906 opti_type = OPTI_TYPE_ZERO_BYTE
7907 | OPTI_TYPE_PRECOMPUTE_INIT
7908 | OPTI_TYPE_PRECOMPUTE_MERKLE
7909 | OPTI_TYPE_EARLY_SKIP
7910 | OPTI_TYPE_NOT_ITERATED
7911 | OPTI_TYPE_PREPENDED_SALT
7912 | OPTI_TYPE_RAW_HASH;
7913 dgst_pos0 = 3;
7914 dgst_pos1 = 7;
7915 dgst_pos2 = 2;
7916 dgst_pos3 = 6;
7917 break;
7918
7919 case 1450: hash_type = HASH_TYPE_SHA256;
7920 salt_type = SALT_TYPE_INTERN;
7921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7922 opts_type = OPTS_TYPE_PT_GENERATE_BE
7923 | OPTS_TYPE_ST_ADD80;
7924 kern_type = KERN_TYPE_HMACSHA256_PW;
7925 dgst_size = DGST_SIZE_4_8;
7926 parse_func = hmacsha256_parse_hash;
7927 sort_by_digest = sort_by_digest_4_8;
7928 opti_type = OPTI_TYPE_ZERO_BYTE
7929 | OPTI_TYPE_NOT_ITERATED;
7930 dgst_pos0 = 3;
7931 dgst_pos1 = 7;
7932 dgst_pos2 = 2;
7933 dgst_pos3 = 6;
7934 break;
7935
7936 case 1460: hash_type = HASH_TYPE_SHA256;
7937 salt_type = SALT_TYPE_INTERN;
7938 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7939 opts_type = OPTS_TYPE_PT_GENERATE_BE
7940 | OPTS_TYPE_PT_ADD80
7941 | OPTS_TYPE_PT_ADDBITS15;
7942 kern_type = KERN_TYPE_HMACSHA256_SLT;
7943 dgst_size = DGST_SIZE_4_8;
7944 parse_func = hmacsha256_parse_hash;
7945 sort_by_digest = sort_by_digest_4_8;
7946 opti_type = OPTI_TYPE_ZERO_BYTE
7947 | OPTI_TYPE_NOT_ITERATED;
7948 dgst_pos0 = 3;
7949 dgst_pos1 = 7;
7950 dgst_pos2 = 2;
7951 dgst_pos3 = 6;
7952 break;
7953
7954 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7955 salt_type = SALT_TYPE_EMBEDDED;
7956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7957 opts_type = OPTS_TYPE_PT_GENERATE_LE
7958 | OPTS_TYPE_PT_BITSLICE;
7959 kern_type = KERN_TYPE_DESCRYPT;
7960 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7961 parse_func = descrypt_parse_hash;
7962 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7963 opti_type = OPTI_TYPE_ZERO_BYTE
7964 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7965 dgst_pos0 = 0;
7966 dgst_pos1 = 1;
7967 dgst_pos2 = 2;
7968 dgst_pos3 = 3;
7969 break;
7970
7971 case 1600: hash_type = HASH_TYPE_MD5;
7972 salt_type = SALT_TYPE_EMBEDDED;
7973 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7974 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7975 kern_type = KERN_TYPE_APR1CRYPT;
7976 dgst_size = DGST_SIZE_4_4;
7977 parse_func = md5apr1_parse_hash;
7978 sort_by_digest = sort_by_digest_4_4;
7979 opti_type = OPTI_TYPE_ZERO_BYTE;
7980 dgst_pos0 = 0;
7981 dgst_pos1 = 1;
7982 dgst_pos2 = 2;
7983 dgst_pos3 = 3;
7984 break;
7985
7986 case 1700: hash_type = HASH_TYPE_SHA512;
7987 salt_type = SALT_TYPE_NONE;
7988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7989 opts_type = OPTS_TYPE_PT_GENERATE_BE
7990 | OPTS_TYPE_PT_ADD80
7991 | OPTS_TYPE_PT_ADDBITS15;
7992 kern_type = KERN_TYPE_SHA512;
7993 dgst_size = DGST_SIZE_8_8;
7994 parse_func = sha512_parse_hash;
7995 sort_by_digest = sort_by_digest_8_8;
7996 opti_type = OPTI_TYPE_ZERO_BYTE
7997 | OPTI_TYPE_PRECOMPUTE_INIT
7998 | OPTI_TYPE_PRECOMPUTE_MERKLE
7999 | OPTI_TYPE_EARLY_SKIP
8000 | OPTI_TYPE_NOT_ITERATED
8001 | OPTI_TYPE_NOT_SALTED
8002 | OPTI_TYPE_USES_BITS_64
8003 | OPTI_TYPE_RAW_HASH;
8004 dgst_pos0 = 14;
8005 dgst_pos1 = 15;
8006 dgst_pos2 = 6;
8007 dgst_pos3 = 7;
8008 break;
8009
8010 case 1710: hash_type = HASH_TYPE_SHA512;
8011 salt_type = SALT_TYPE_INTERN;
8012 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8013 opts_type = OPTS_TYPE_PT_GENERATE_BE
8014 | OPTS_TYPE_ST_ADD80
8015 | OPTS_TYPE_ST_ADDBITS15;
8016 kern_type = KERN_TYPE_SHA512_PWSLT;
8017 dgst_size = DGST_SIZE_8_8;
8018 parse_func = sha512s_parse_hash;
8019 sort_by_digest = sort_by_digest_8_8;
8020 opti_type = OPTI_TYPE_ZERO_BYTE
8021 | OPTI_TYPE_PRECOMPUTE_INIT
8022 | OPTI_TYPE_PRECOMPUTE_MERKLE
8023 | OPTI_TYPE_EARLY_SKIP
8024 | OPTI_TYPE_NOT_ITERATED
8025 | OPTI_TYPE_APPENDED_SALT
8026 | OPTI_TYPE_USES_BITS_64
8027 | OPTI_TYPE_RAW_HASH;
8028 dgst_pos0 = 14;
8029 dgst_pos1 = 15;
8030 dgst_pos2 = 6;
8031 dgst_pos3 = 7;
8032 break;
8033
8034 case 1711: hash_type = HASH_TYPE_SHA512;
8035 salt_type = SALT_TYPE_EMBEDDED;
8036 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8037 opts_type = OPTS_TYPE_PT_GENERATE_BE
8038 | OPTS_TYPE_ST_ADD80
8039 | OPTS_TYPE_ST_ADDBITS15;
8040 kern_type = KERN_TYPE_SHA512_PWSLT;
8041 dgst_size = DGST_SIZE_8_8;
8042 parse_func = sha512b64s_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_APPENDED_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 1720: 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_PT_ADD80
8063 | OPTS_TYPE_PT_ADDBITS15;
8064 kern_type = KERN_TYPE_SHA512_SLTPW;
8065 dgst_size = DGST_SIZE_8_8;
8066 parse_func = sha512s_parse_hash;
8067 sort_by_digest = sort_by_digest_8_8;
8068 opti_type = OPTI_TYPE_ZERO_BYTE
8069 | OPTI_TYPE_PRECOMPUTE_INIT
8070 | OPTI_TYPE_PRECOMPUTE_MERKLE
8071 | OPTI_TYPE_EARLY_SKIP
8072 | OPTI_TYPE_NOT_ITERATED
8073 | OPTI_TYPE_PREPENDED_SALT
8074 | OPTI_TYPE_USES_BITS_64
8075 | OPTI_TYPE_RAW_HASH;
8076 dgst_pos0 = 14;
8077 dgst_pos1 = 15;
8078 dgst_pos2 = 6;
8079 dgst_pos3 = 7;
8080 break;
8081
8082 case 1722: hash_type = HASH_TYPE_SHA512;
8083 salt_type = SALT_TYPE_EMBEDDED;
8084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8085 opts_type = OPTS_TYPE_PT_GENERATE_BE
8086 | OPTS_TYPE_PT_ADD80
8087 | OPTS_TYPE_PT_ADDBITS15
8088 | OPTS_TYPE_ST_HEX;
8089 kern_type = KERN_TYPE_SHA512_SLTPW;
8090 dgst_size = DGST_SIZE_8_8;
8091 parse_func = osx512_parse_hash;
8092 sort_by_digest = sort_by_digest_8_8;
8093 opti_type = OPTI_TYPE_ZERO_BYTE
8094 | OPTI_TYPE_PRECOMPUTE_INIT
8095 | OPTI_TYPE_PRECOMPUTE_MERKLE
8096 | OPTI_TYPE_EARLY_SKIP
8097 | OPTI_TYPE_NOT_ITERATED
8098 | OPTI_TYPE_PREPENDED_SALT
8099 | OPTI_TYPE_USES_BITS_64
8100 | OPTI_TYPE_RAW_HASH;
8101 dgst_pos0 = 14;
8102 dgst_pos1 = 15;
8103 dgst_pos2 = 6;
8104 dgst_pos3 = 7;
8105 break;
8106
8107 case 1730: hash_type = HASH_TYPE_SHA512;
8108 salt_type = SALT_TYPE_INTERN;
8109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8110 opts_type = OPTS_TYPE_PT_GENERATE_BE
8111 | OPTS_TYPE_PT_UNICODE
8112 | OPTS_TYPE_ST_ADD80
8113 | OPTS_TYPE_ST_ADDBITS15;
8114 kern_type = KERN_TYPE_SHA512_PWSLTU;
8115 dgst_size = DGST_SIZE_8_8;
8116 parse_func = sha512s_parse_hash;
8117 sort_by_digest = sort_by_digest_8_8;
8118 opti_type = OPTI_TYPE_ZERO_BYTE
8119 | OPTI_TYPE_PRECOMPUTE_INIT
8120 | OPTI_TYPE_PRECOMPUTE_MERKLE
8121 | OPTI_TYPE_EARLY_SKIP
8122 | OPTI_TYPE_NOT_ITERATED
8123 | OPTI_TYPE_APPENDED_SALT
8124 | OPTI_TYPE_USES_BITS_64
8125 | OPTI_TYPE_RAW_HASH;
8126 dgst_pos0 = 14;
8127 dgst_pos1 = 15;
8128 dgst_pos2 = 6;
8129 dgst_pos3 = 7;
8130 break;
8131
8132 case 1731: hash_type = HASH_TYPE_SHA512;
8133 salt_type = SALT_TYPE_EMBEDDED;
8134 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8135 opts_type = OPTS_TYPE_PT_GENERATE_BE
8136 | OPTS_TYPE_PT_UNICODE
8137 | OPTS_TYPE_ST_ADD80
8138 | OPTS_TYPE_ST_ADDBITS15
8139 | OPTS_TYPE_ST_HEX;
8140 kern_type = KERN_TYPE_SHA512_PWSLTU;
8141 dgst_size = DGST_SIZE_8_8;
8142 parse_func = mssql2012_parse_hash;
8143 sort_by_digest = sort_by_digest_8_8;
8144 opti_type = OPTI_TYPE_ZERO_BYTE
8145 | OPTI_TYPE_PRECOMPUTE_INIT
8146 | OPTI_TYPE_PRECOMPUTE_MERKLE
8147 | OPTI_TYPE_EARLY_SKIP
8148 | OPTI_TYPE_NOT_ITERATED
8149 | OPTI_TYPE_APPENDED_SALT
8150 | OPTI_TYPE_USES_BITS_64
8151 | OPTI_TYPE_RAW_HASH;
8152 dgst_pos0 = 14;
8153 dgst_pos1 = 15;
8154 dgst_pos2 = 6;
8155 dgst_pos3 = 7;
8156 break;
8157
8158 case 1740: hash_type = HASH_TYPE_SHA512;
8159 salt_type = SALT_TYPE_INTERN;
8160 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8161 opts_type = OPTS_TYPE_PT_GENERATE_BE
8162 | OPTS_TYPE_PT_ADD80
8163 | OPTS_TYPE_PT_ADDBITS15
8164 | OPTS_TYPE_PT_UNICODE;
8165 kern_type = KERN_TYPE_SHA512_SLTPWU;
8166 dgst_size = DGST_SIZE_8_8;
8167 parse_func = sha512s_parse_hash;
8168 sort_by_digest = sort_by_digest_8_8;
8169 opti_type = OPTI_TYPE_ZERO_BYTE
8170 | OPTI_TYPE_PRECOMPUTE_INIT
8171 | OPTI_TYPE_PRECOMPUTE_MERKLE
8172 | OPTI_TYPE_EARLY_SKIP
8173 | OPTI_TYPE_NOT_ITERATED
8174 | OPTI_TYPE_PREPENDED_SALT
8175 | OPTI_TYPE_USES_BITS_64
8176 | OPTI_TYPE_RAW_HASH;
8177 dgst_pos0 = 14;
8178 dgst_pos1 = 15;
8179 dgst_pos2 = 6;
8180 dgst_pos3 = 7;
8181 break;
8182
8183 case 1750: hash_type = HASH_TYPE_SHA512;
8184 salt_type = SALT_TYPE_INTERN;
8185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8186 opts_type = OPTS_TYPE_PT_GENERATE_BE
8187 | OPTS_TYPE_ST_ADD80;
8188 kern_type = KERN_TYPE_HMACSHA512_PW;
8189 dgst_size = DGST_SIZE_8_8;
8190 parse_func = hmacsha512_parse_hash;
8191 sort_by_digest = sort_by_digest_8_8;
8192 opti_type = OPTI_TYPE_ZERO_BYTE
8193 | OPTI_TYPE_USES_BITS_64
8194 | OPTI_TYPE_NOT_ITERATED;
8195 dgst_pos0 = 14;
8196 dgst_pos1 = 15;
8197 dgst_pos2 = 6;
8198 dgst_pos3 = 7;
8199 break;
8200
8201 case 1760: hash_type = HASH_TYPE_SHA512;
8202 salt_type = SALT_TYPE_INTERN;
8203 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8204 opts_type = OPTS_TYPE_PT_GENERATE_BE
8205 | OPTS_TYPE_PT_ADD80
8206 | OPTS_TYPE_PT_ADDBITS15;
8207 kern_type = KERN_TYPE_HMACSHA512_SLT;
8208 dgst_size = DGST_SIZE_8_8;
8209 parse_func = hmacsha512_parse_hash;
8210 sort_by_digest = sort_by_digest_8_8;
8211 opti_type = OPTI_TYPE_ZERO_BYTE
8212 | OPTI_TYPE_USES_BITS_64
8213 | OPTI_TYPE_NOT_ITERATED;
8214 dgst_pos0 = 14;
8215 dgst_pos1 = 15;
8216 dgst_pos2 = 6;
8217 dgst_pos3 = 7;
8218 break;
8219
8220 case 1800: hash_type = HASH_TYPE_SHA512;
8221 salt_type = SALT_TYPE_EMBEDDED;
8222 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8223 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8224 kern_type = KERN_TYPE_SHA512CRYPT;
8225 dgst_size = DGST_SIZE_8_8;
8226 parse_func = sha512crypt_parse_hash;
8227 sort_by_digest = sort_by_digest_8_8;
8228 opti_type = OPTI_TYPE_ZERO_BYTE
8229 | OPTI_TYPE_USES_BITS_64;
8230 dgst_pos0 = 0;
8231 dgst_pos1 = 1;
8232 dgst_pos2 = 2;
8233 dgst_pos3 = 3;
8234 break;
8235
8236 case 2100: hash_type = HASH_TYPE_DCC2;
8237 salt_type = SALT_TYPE_EMBEDDED;
8238 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8239 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8240 | OPTS_TYPE_ST_LOWER
8241 | OPTS_TYPE_ST_UNICODE;
8242 kern_type = KERN_TYPE_DCC2;
8243 dgst_size = DGST_SIZE_4_4;
8244 parse_func = dcc2_parse_hash;
8245 sort_by_digest = sort_by_digest_4_4;
8246 opti_type = OPTI_TYPE_ZERO_BYTE;
8247 dgst_pos0 = 0;
8248 dgst_pos1 = 1;
8249 dgst_pos2 = 2;
8250 dgst_pos3 = 3;
8251 break;
8252
8253 case 2400: hash_type = HASH_TYPE_MD5;
8254 salt_type = SALT_TYPE_NONE;
8255 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8256 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8257 kern_type = KERN_TYPE_MD5PIX;
8258 dgst_size = DGST_SIZE_4_4;
8259 parse_func = md5pix_parse_hash;
8260 sort_by_digest = sort_by_digest_4_4;
8261 opti_type = OPTI_TYPE_ZERO_BYTE
8262 | OPTI_TYPE_PRECOMPUTE_INIT
8263 | OPTI_TYPE_PRECOMPUTE_MERKLE
8264 | OPTI_TYPE_EARLY_SKIP
8265 | OPTI_TYPE_NOT_ITERATED
8266 | OPTI_TYPE_NOT_SALTED;
8267 dgst_pos0 = 0;
8268 dgst_pos1 = 3;
8269 dgst_pos2 = 2;
8270 dgst_pos3 = 1;
8271 break;
8272
8273 case 2410: hash_type = HASH_TYPE_MD5;
8274 salt_type = SALT_TYPE_INTERN;
8275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8276 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8277 kern_type = KERN_TYPE_MD5ASA;
8278 dgst_size = DGST_SIZE_4_4;
8279 parse_func = md5asa_parse_hash;
8280 sort_by_digest = sort_by_digest_4_4;
8281 opti_type = OPTI_TYPE_ZERO_BYTE
8282 | OPTI_TYPE_PRECOMPUTE_INIT
8283 | OPTI_TYPE_PRECOMPUTE_MERKLE
8284 | OPTI_TYPE_EARLY_SKIP
8285 | OPTI_TYPE_NOT_ITERATED;
8286 dgst_pos0 = 0;
8287 dgst_pos1 = 3;
8288 dgst_pos2 = 2;
8289 dgst_pos3 = 1;
8290 break;
8291
8292 case 2500: hash_type = HASH_TYPE_WPA;
8293 salt_type = SALT_TYPE_EMBEDDED;
8294 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8295 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8296 kern_type = KERN_TYPE_WPA;
8297 dgst_size = DGST_SIZE_4_4;
8298 parse_func = wpa_parse_hash;
8299 sort_by_digest = sort_by_digest_4_4;
8300 opti_type = OPTI_TYPE_ZERO_BYTE;
8301 dgst_pos0 = 0;
8302 dgst_pos1 = 1;
8303 dgst_pos2 = 2;
8304 dgst_pos3 = 3;
8305 break;
8306
8307 case 2600: hash_type = HASH_TYPE_MD5;
8308 salt_type = SALT_TYPE_VIRTUAL;
8309 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8310 opts_type = OPTS_TYPE_PT_GENERATE_LE
8311 | OPTS_TYPE_PT_ADD80
8312 | OPTS_TYPE_PT_ADDBITS14
8313 | OPTS_TYPE_ST_ADD80;
8314 kern_type = KERN_TYPE_MD55_PWSLT1;
8315 dgst_size = DGST_SIZE_4_4;
8316 parse_func = md5md5_parse_hash;
8317 sort_by_digest = sort_by_digest_4_4;
8318 opti_type = OPTI_TYPE_ZERO_BYTE
8319 | OPTI_TYPE_PRECOMPUTE_INIT
8320 | OPTI_TYPE_PRECOMPUTE_MERKLE
8321 | OPTI_TYPE_EARLY_SKIP;
8322 dgst_pos0 = 0;
8323 dgst_pos1 = 3;
8324 dgst_pos2 = 2;
8325 dgst_pos3 = 1;
8326 break;
8327
8328 case 2611: hash_type = HASH_TYPE_MD5;
8329 salt_type = SALT_TYPE_INTERN;
8330 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8331 opts_type = OPTS_TYPE_PT_GENERATE_LE
8332 | OPTS_TYPE_PT_ADD80
8333 | OPTS_TYPE_PT_ADDBITS14
8334 | OPTS_TYPE_ST_ADD80;
8335 kern_type = KERN_TYPE_MD55_PWSLT1;
8336 dgst_size = DGST_SIZE_4_4;
8337 parse_func = vb3_parse_hash;
8338 sort_by_digest = sort_by_digest_4_4;
8339 opti_type = OPTI_TYPE_ZERO_BYTE
8340 | OPTI_TYPE_PRECOMPUTE_INIT
8341 | OPTI_TYPE_PRECOMPUTE_MERKLE
8342 | OPTI_TYPE_EARLY_SKIP;
8343 dgst_pos0 = 0;
8344 dgst_pos1 = 3;
8345 dgst_pos2 = 2;
8346 dgst_pos3 = 1;
8347 break;
8348
8349 case 2612: hash_type = HASH_TYPE_MD5;
8350 salt_type = SALT_TYPE_EMBEDDED;
8351 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8352 opts_type = OPTS_TYPE_PT_GENERATE_LE
8353 | OPTS_TYPE_PT_ADD80
8354 | OPTS_TYPE_PT_ADDBITS14
8355 | OPTS_TYPE_ST_ADD80
8356 | OPTS_TYPE_ST_HEX;
8357 kern_type = KERN_TYPE_MD55_PWSLT1;
8358 dgst_size = DGST_SIZE_4_4;
8359 parse_func = phps_parse_hash;
8360 sort_by_digest = sort_by_digest_4_4;
8361 opti_type = OPTI_TYPE_ZERO_BYTE
8362 | OPTI_TYPE_PRECOMPUTE_INIT
8363 | OPTI_TYPE_PRECOMPUTE_MERKLE
8364 | OPTI_TYPE_EARLY_SKIP;
8365 dgst_pos0 = 0;
8366 dgst_pos1 = 3;
8367 dgst_pos2 = 2;
8368 dgst_pos3 = 1;
8369 break;
8370
8371 case 2711: hash_type = HASH_TYPE_MD5;
8372 salt_type = SALT_TYPE_INTERN;
8373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8374 opts_type = OPTS_TYPE_PT_GENERATE_LE
8375 | OPTS_TYPE_PT_ADD80
8376 | OPTS_TYPE_PT_ADDBITS14
8377 | OPTS_TYPE_ST_ADD80;
8378 kern_type = KERN_TYPE_MD55_PWSLT2;
8379 dgst_size = DGST_SIZE_4_4;
8380 parse_func = vb30_parse_hash;
8381 sort_by_digest = sort_by_digest_4_4;
8382 opti_type = OPTI_TYPE_ZERO_BYTE
8383 | OPTI_TYPE_PRECOMPUTE_INIT
8384 | OPTI_TYPE_EARLY_SKIP;
8385 dgst_pos0 = 0;
8386 dgst_pos1 = 3;
8387 dgst_pos2 = 2;
8388 dgst_pos3 = 1;
8389 break;
8390
8391 case 2811: hash_type = HASH_TYPE_MD5;
8392 salt_type = SALT_TYPE_INTERN;
8393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8394 opts_type = OPTS_TYPE_PT_GENERATE_LE
8395 | OPTS_TYPE_PT_ADD80
8396 | OPTS_TYPE_PT_ADDBITS14;
8397 kern_type = KERN_TYPE_MD55_SLTPW;
8398 dgst_size = DGST_SIZE_4_4;
8399 parse_func = ipb2_parse_hash;
8400 sort_by_digest = sort_by_digest_4_4;
8401 opti_type = OPTI_TYPE_ZERO_BYTE
8402 | OPTI_TYPE_PRECOMPUTE_INIT
8403 | OPTI_TYPE_EARLY_SKIP;
8404 dgst_pos0 = 0;
8405 dgst_pos1 = 3;
8406 dgst_pos2 = 2;
8407 dgst_pos3 = 1;
8408 break;
8409
8410 case 3000: hash_type = HASH_TYPE_LM;
8411 salt_type = SALT_TYPE_NONE;
8412 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8413 opts_type = OPTS_TYPE_PT_GENERATE_LE
8414 | OPTS_TYPE_PT_UPPER
8415 | OPTS_TYPE_PT_BITSLICE;
8416 kern_type = KERN_TYPE_LM;
8417 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8418 parse_func = lm_parse_hash;
8419 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8420 opti_type = OPTI_TYPE_ZERO_BYTE
8421 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8422 dgst_pos0 = 0;
8423 dgst_pos1 = 1;
8424 dgst_pos2 = 2;
8425 dgst_pos3 = 3;
8426 break;
8427
8428 case 3100: hash_type = HASH_TYPE_ORACLEH;
8429 salt_type = SALT_TYPE_INTERN;
8430 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8431 opts_type = OPTS_TYPE_PT_GENERATE_LE
8432 | OPTS_TYPE_PT_UPPER
8433 | OPTS_TYPE_ST_UPPER;
8434 kern_type = KERN_TYPE_ORACLEH;
8435 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8436 parse_func = oracleh_parse_hash;
8437 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8438 opti_type = OPTI_TYPE_ZERO_BYTE;
8439 dgst_pos0 = 0;
8440 dgst_pos1 = 1;
8441 dgst_pos2 = 2;
8442 dgst_pos3 = 3;
8443 break;
8444
8445 case 3200: hash_type = HASH_TYPE_BCRYPT;
8446 salt_type = SALT_TYPE_EMBEDDED;
8447 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8448 opts_type = OPTS_TYPE_PT_GENERATE_LE
8449 | OPTS_TYPE_ST_GENERATE_LE;
8450 kern_type = KERN_TYPE_BCRYPT;
8451 dgst_size = DGST_SIZE_4_6;
8452 parse_func = bcrypt_parse_hash;
8453 sort_by_digest = sort_by_digest_4_6;
8454 opti_type = OPTI_TYPE_ZERO_BYTE;
8455 dgst_pos0 = 0;
8456 dgst_pos1 = 1;
8457 dgst_pos2 = 2;
8458 dgst_pos3 = 3;
8459 break;
8460
8461 case 3710: hash_type = HASH_TYPE_MD5;
8462 salt_type = SALT_TYPE_INTERN;
8463 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8464 opts_type = OPTS_TYPE_PT_GENERATE_LE
8465 | OPTS_TYPE_PT_ADD80
8466 | OPTS_TYPE_PT_ADDBITS14;
8467 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8468 dgst_size = DGST_SIZE_4_4;
8469 parse_func = md5s_parse_hash;
8470 sort_by_digest = sort_by_digest_4_4;
8471 opti_type = OPTI_TYPE_ZERO_BYTE
8472 | OPTI_TYPE_PRECOMPUTE_INIT
8473 | OPTI_TYPE_PRECOMPUTE_MERKLE
8474 | OPTI_TYPE_EARLY_SKIP;
8475 dgst_pos0 = 0;
8476 dgst_pos1 = 3;
8477 dgst_pos2 = 2;
8478 dgst_pos3 = 1;
8479 break;
8480
8481 case 3711: hash_type = HASH_TYPE_MD5;
8482 salt_type = SALT_TYPE_EMBEDDED;
8483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8484 opts_type = OPTS_TYPE_PT_GENERATE_LE
8485 | OPTS_TYPE_PT_ADD80
8486 | OPTS_TYPE_PT_ADDBITS14;
8487 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8488 dgst_size = DGST_SIZE_4_4;
8489 parse_func = mediawiki_b_parse_hash;
8490 sort_by_digest = sort_by_digest_4_4;
8491 opti_type = OPTI_TYPE_ZERO_BYTE
8492 | OPTI_TYPE_PRECOMPUTE_INIT
8493 | OPTI_TYPE_PRECOMPUTE_MERKLE
8494 | OPTI_TYPE_EARLY_SKIP;
8495 dgst_pos0 = 0;
8496 dgst_pos1 = 3;
8497 dgst_pos2 = 2;
8498 dgst_pos3 = 1;
8499 break;
8500
8501 case 3800: hash_type = HASH_TYPE_MD5;
8502 salt_type = SALT_TYPE_INTERN;
8503 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8504 opts_type = OPTS_TYPE_PT_GENERATE_LE
8505 | OPTS_TYPE_ST_ADDBITS14;
8506 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8507 dgst_size = DGST_SIZE_4_4;
8508 parse_func = md5s_parse_hash;
8509 sort_by_digest = sort_by_digest_4_4;
8510 opti_type = OPTI_TYPE_ZERO_BYTE
8511 | OPTI_TYPE_PRECOMPUTE_INIT
8512 | OPTI_TYPE_PRECOMPUTE_MERKLE
8513 | OPTI_TYPE_EARLY_SKIP
8514 | OPTI_TYPE_NOT_ITERATED
8515 | OPTI_TYPE_RAW_HASH;
8516 dgst_pos0 = 0;
8517 dgst_pos1 = 3;
8518 dgst_pos2 = 2;
8519 dgst_pos3 = 1;
8520 break;
8521
8522 case 4300: hash_type = HASH_TYPE_MD5;
8523 salt_type = SALT_TYPE_VIRTUAL;
8524 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8525 opts_type = OPTS_TYPE_PT_GENERATE_LE
8526 | OPTS_TYPE_PT_ADD80
8527 | OPTS_TYPE_PT_ADDBITS14
8528 | OPTS_TYPE_ST_ADD80;
8529 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8530 dgst_size = DGST_SIZE_4_4;
8531 parse_func = md5md5_parse_hash;
8532 sort_by_digest = sort_by_digest_4_4;
8533 opti_type = OPTI_TYPE_ZERO_BYTE
8534 | OPTI_TYPE_PRECOMPUTE_INIT
8535 | OPTI_TYPE_PRECOMPUTE_MERKLE
8536 | OPTI_TYPE_EARLY_SKIP;
8537 dgst_pos0 = 0;
8538 dgst_pos1 = 3;
8539 dgst_pos2 = 2;
8540 dgst_pos3 = 1;
8541 break;
8542
8543
8544 case 4400: hash_type = HASH_TYPE_MD5;
8545 salt_type = SALT_TYPE_NONE;
8546 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8547 opts_type = OPTS_TYPE_PT_GENERATE_BE
8548 | OPTS_TYPE_PT_ADD80
8549 | OPTS_TYPE_PT_ADDBITS15;
8550 kern_type = KERN_TYPE_MD5_SHA1;
8551 dgst_size = DGST_SIZE_4_4;
8552 parse_func = md5_parse_hash;
8553 sort_by_digest = sort_by_digest_4_4;
8554 opti_type = OPTI_TYPE_ZERO_BYTE
8555 | OPTI_TYPE_PRECOMPUTE_INIT
8556 | OPTI_TYPE_PRECOMPUTE_MERKLE
8557 | OPTI_TYPE_EARLY_SKIP
8558 | OPTI_TYPE_NOT_ITERATED
8559 | OPTI_TYPE_NOT_SALTED
8560 | OPTI_TYPE_RAW_HASH;
8561 dgst_pos0 = 0;
8562 dgst_pos1 = 3;
8563 dgst_pos2 = 2;
8564 dgst_pos3 = 1;
8565 break;
8566
8567 case 4500: hash_type = HASH_TYPE_SHA1;
8568 salt_type = SALT_TYPE_NONE;
8569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8570 opts_type = OPTS_TYPE_PT_GENERATE_BE
8571 | OPTS_TYPE_PT_ADD80
8572 | OPTS_TYPE_PT_ADDBITS15;
8573 kern_type = KERN_TYPE_SHA11;
8574 dgst_size = DGST_SIZE_4_5;
8575 parse_func = sha1_parse_hash;
8576 sort_by_digest = sort_by_digest_4_5;
8577 opti_type = OPTI_TYPE_ZERO_BYTE
8578 | OPTI_TYPE_PRECOMPUTE_INIT
8579 | OPTI_TYPE_PRECOMPUTE_MERKLE
8580 | OPTI_TYPE_EARLY_SKIP
8581 | OPTI_TYPE_NOT_SALTED;
8582 dgst_pos0 = 3;
8583 dgst_pos1 = 4;
8584 dgst_pos2 = 2;
8585 dgst_pos3 = 1;
8586 break;
8587
8588 case 4700: hash_type = HASH_TYPE_SHA1;
8589 salt_type = SALT_TYPE_NONE;
8590 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8591 opts_type = OPTS_TYPE_PT_GENERATE_LE
8592 | OPTS_TYPE_PT_ADD80
8593 | OPTS_TYPE_PT_ADDBITS14;
8594 kern_type = KERN_TYPE_SHA1_MD5;
8595 dgst_size = DGST_SIZE_4_5;
8596 parse_func = sha1_parse_hash;
8597 sort_by_digest = sort_by_digest_4_5;
8598 opti_type = OPTI_TYPE_ZERO_BYTE
8599 | OPTI_TYPE_PRECOMPUTE_INIT
8600 | OPTI_TYPE_PRECOMPUTE_MERKLE
8601 | OPTI_TYPE_EARLY_SKIP
8602 | OPTI_TYPE_NOT_ITERATED
8603 | OPTI_TYPE_NOT_SALTED
8604 | OPTI_TYPE_RAW_HASH;
8605 dgst_pos0 = 3;
8606 dgst_pos1 = 4;
8607 dgst_pos2 = 2;
8608 dgst_pos3 = 1;
8609 break;
8610
8611 case 4800: hash_type = HASH_TYPE_MD5;
8612 salt_type = SALT_TYPE_EMBEDDED;
8613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8614 opts_type = OPTS_TYPE_PT_GENERATE_LE
8615 | OPTS_TYPE_PT_ADDBITS14;
8616 kern_type = KERN_TYPE_MD5_CHAP;
8617 dgst_size = DGST_SIZE_4_4;
8618 parse_func = chap_parse_hash;
8619 sort_by_digest = sort_by_digest_4_4;
8620 opti_type = OPTI_TYPE_ZERO_BYTE
8621 | OPTI_TYPE_PRECOMPUTE_INIT
8622 | OPTI_TYPE_PRECOMPUTE_MERKLE
8623 | OPTI_TYPE_MEET_IN_MIDDLE
8624 | OPTI_TYPE_EARLY_SKIP
8625 | OPTI_TYPE_NOT_ITERATED
8626 | OPTI_TYPE_RAW_HASH;
8627 dgst_pos0 = 0;
8628 dgst_pos1 = 3;
8629 dgst_pos2 = 2;
8630 dgst_pos3 = 1;
8631 break;
8632
8633 case 4900: hash_type = HASH_TYPE_SHA1;
8634 salt_type = SALT_TYPE_INTERN;
8635 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8636 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8637 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8638 dgst_size = DGST_SIZE_4_5;
8639 parse_func = sha1s_parse_hash;
8640 sort_by_digest = sort_by_digest_4_5;
8641 opti_type = OPTI_TYPE_ZERO_BYTE
8642 | OPTI_TYPE_PRECOMPUTE_INIT
8643 | OPTI_TYPE_PRECOMPUTE_MERKLE
8644 | OPTI_TYPE_EARLY_SKIP;
8645 dgst_pos0 = 3;
8646 dgst_pos1 = 4;
8647 dgst_pos2 = 2;
8648 dgst_pos3 = 1;
8649 break;
8650
8651 case 5000: hash_type = HASH_TYPE_KECCAK;
8652 salt_type = SALT_TYPE_EMBEDDED;
8653 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8654 opts_type = OPTS_TYPE_PT_GENERATE_LE
8655 | OPTS_TYPE_PT_ADD01;
8656 kern_type = KERN_TYPE_KECCAK;
8657 dgst_size = DGST_SIZE_8_25;
8658 parse_func = keccak_parse_hash;
8659 sort_by_digest = sort_by_digest_8_25;
8660 opti_type = OPTI_TYPE_ZERO_BYTE
8661 | OPTI_TYPE_USES_BITS_64
8662 | OPTI_TYPE_RAW_HASH;
8663 dgst_pos0 = 2;
8664 dgst_pos1 = 3;
8665 dgst_pos2 = 4;
8666 dgst_pos3 = 5;
8667 break;
8668
8669 case 5100: hash_type = HASH_TYPE_MD5H;
8670 salt_type = SALT_TYPE_NONE;
8671 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8672 opts_type = OPTS_TYPE_PT_GENERATE_LE
8673 | OPTS_TYPE_PT_ADD80
8674 | OPTS_TYPE_PT_ADDBITS14;
8675 kern_type = KERN_TYPE_MD5H;
8676 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8677 parse_func = md5half_parse_hash;
8678 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8679 opti_type = OPTI_TYPE_ZERO_BYTE
8680 | OPTI_TYPE_RAW_HASH;
8681 dgst_pos0 = 0;
8682 dgst_pos1 = 1;
8683 dgst_pos2 = 2;
8684 dgst_pos3 = 3;
8685 break;
8686
8687 case 5200: hash_type = HASH_TYPE_SHA256;
8688 salt_type = SALT_TYPE_EMBEDDED;
8689 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8690 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8691 kern_type = KERN_TYPE_PSAFE3;
8692 dgst_size = DGST_SIZE_4_8;
8693 parse_func = psafe3_parse_hash;
8694 sort_by_digest = sort_by_digest_4_8;
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 5300: hash_type = HASH_TYPE_MD5;
8703 salt_type = SALT_TYPE_EMBEDDED;
8704 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8705 opts_type = OPTS_TYPE_PT_GENERATE_LE
8706 | OPTS_TYPE_ST_ADD80;
8707 kern_type = KERN_TYPE_IKEPSK_MD5;
8708 dgst_size = DGST_SIZE_4_4;
8709 parse_func = ikepsk_md5_parse_hash;
8710 sort_by_digest = sort_by_digest_4_4;
8711 opti_type = OPTI_TYPE_ZERO_BYTE;
8712 dgst_pos0 = 0;
8713 dgst_pos1 = 3;
8714 dgst_pos2 = 2;
8715 dgst_pos3 = 1;
8716 break;
8717
8718 case 5400: hash_type = HASH_TYPE_SHA1;
8719 salt_type = SALT_TYPE_EMBEDDED;
8720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8721 opts_type = OPTS_TYPE_PT_GENERATE_BE
8722 | OPTS_TYPE_ST_ADD80;
8723 kern_type = KERN_TYPE_IKEPSK_SHA1;
8724 dgst_size = DGST_SIZE_4_5;
8725 parse_func = ikepsk_sha1_parse_hash;
8726 sort_by_digest = sort_by_digest_4_5;
8727 opti_type = OPTI_TYPE_ZERO_BYTE;
8728 dgst_pos0 = 3;
8729 dgst_pos1 = 4;
8730 dgst_pos2 = 2;
8731 dgst_pos3 = 1;
8732 break;
8733
8734 case 5500: hash_type = HASH_TYPE_NETNTLM;
8735 salt_type = SALT_TYPE_EMBEDDED;
8736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8737 opts_type = OPTS_TYPE_PT_GENERATE_LE
8738 | OPTS_TYPE_PT_ADD80
8739 | OPTS_TYPE_PT_ADDBITS14
8740 | OPTS_TYPE_PT_UNICODE
8741 | OPTS_TYPE_ST_HEX;
8742 kern_type = KERN_TYPE_NETNTLMv1;
8743 dgst_size = DGST_SIZE_4_4;
8744 parse_func = netntlmv1_parse_hash;
8745 sort_by_digest = sort_by_digest_4_4;
8746 opti_type = OPTI_TYPE_ZERO_BYTE
8747 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8748 dgst_pos0 = 0;
8749 dgst_pos1 = 1;
8750 dgst_pos2 = 2;
8751 dgst_pos3 = 3;
8752 break;
8753
8754 case 5600: hash_type = HASH_TYPE_MD5;
8755 salt_type = SALT_TYPE_EMBEDDED;
8756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8757 opts_type = OPTS_TYPE_PT_GENERATE_LE
8758 | OPTS_TYPE_PT_ADD80
8759 | OPTS_TYPE_PT_ADDBITS14
8760 | OPTS_TYPE_PT_UNICODE;
8761 kern_type = KERN_TYPE_NETNTLMv2;
8762 dgst_size = DGST_SIZE_4_4;
8763 parse_func = netntlmv2_parse_hash;
8764 sort_by_digest = sort_by_digest_4_4;
8765 opti_type = OPTI_TYPE_ZERO_BYTE;
8766 dgst_pos0 = 0;
8767 dgst_pos1 = 3;
8768 dgst_pos2 = 2;
8769 dgst_pos3 = 1;
8770 break;
8771
8772 case 5700: hash_type = HASH_TYPE_SHA256;
8773 salt_type = SALT_TYPE_NONE;
8774 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8775 opts_type = OPTS_TYPE_PT_GENERATE_BE
8776 | OPTS_TYPE_PT_ADD80
8777 | OPTS_TYPE_PT_ADDBITS15;
8778 kern_type = KERN_TYPE_SHA256;
8779 dgst_size = DGST_SIZE_4_8;
8780 parse_func = cisco4_parse_hash;
8781 sort_by_digest = sort_by_digest_4_8;
8782 opti_type = OPTI_TYPE_ZERO_BYTE
8783 | OPTI_TYPE_PRECOMPUTE_INIT
8784 | OPTI_TYPE_PRECOMPUTE_MERKLE
8785 | OPTI_TYPE_EARLY_SKIP
8786 | OPTI_TYPE_NOT_ITERATED
8787 | OPTI_TYPE_NOT_SALTED
8788 | OPTI_TYPE_RAW_HASH;
8789 dgst_pos0 = 3;
8790 dgst_pos1 = 7;
8791 dgst_pos2 = 2;
8792 dgst_pos3 = 6;
8793 break;
8794
8795 case 5800: hash_type = HASH_TYPE_SHA1;
8796 salt_type = SALT_TYPE_INTERN;
8797 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8798 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8799 | OPTS_TYPE_ST_ADD80;
8800 kern_type = KERN_TYPE_ANDROIDPIN;
8801 dgst_size = DGST_SIZE_4_5;
8802 parse_func = androidpin_parse_hash;
8803 sort_by_digest = sort_by_digest_4_5;
8804 opti_type = OPTI_TYPE_ZERO_BYTE;
8805 dgst_pos0 = 0;
8806 dgst_pos1 = 1;
8807 dgst_pos2 = 2;
8808 dgst_pos3 = 3;
8809 break;
8810
8811 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8812 salt_type = SALT_TYPE_NONE;
8813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8814 opts_type = OPTS_TYPE_PT_GENERATE_LE
8815 | OPTS_TYPE_PT_ADD80;
8816 kern_type = KERN_TYPE_RIPEMD160;
8817 dgst_size = DGST_SIZE_4_5;
8818 parse_func = ripemd160_parse_hash;
8819 sort_by_digest = sort_by_digest_4_5;
8820 opti_type = OPTI_TYPE_ZERO_BYTE;
8821 dgst_pos0 = 0;
8822 dgst_pos1 = 1;
8823 dgst_pos2 = 2;
8824 dgst_pos3 = 3;
8825 break;
8826
8827 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8828 salt_type = SALT_TYPE_NONE;
8829 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8830 opts_type = OPTS_TYPE_PT_GENERATE_BE
8831 | OPTS_TYPE_PT_ADD80;
8832 kern_type = KERN_TYPE_WHIRLPOOL;
8833 dgst_size = DGST_SIZE_4_16;
8834 parse_func = whirlpool_parse_hash;
8835 sort_by_digest = sort_by_digest_4_16;
8836 opti_type = OPTI_TYPE_ZERO_BYTE;
8837 dgst_pos0 = 0;
8838 dgst_pos1 = 1;
8839 dgst_pos2 = 2;
8840 dgst_pos3 = 3;
8841 break;
8842
8843 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8844 salt_type = SALT_TYPE_EMBEDDED;
8845 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8846 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8847 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8848 dgst_size = DGST_SIZE_4_5;
8849 parse_func = truecrypt_parse_hash_2k;
8850 sort_by_digest = sort_by_digest_4_5;
8851 opti_type = OPTI_TYPE_ZERO_BYTE;
8852 dgst_pos0 = 0;
8853 dgst_pos1 = 1;
8854 dgst_pos2 = 2;
8855 dgst_pos3 = 3;
8856 break;
8857
8858 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8859 salt_type = SALT_TYPE_EMBEDDED;
8860 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8861 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8862 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8863 dgst_size = DGST_SIZE_4_5;
8864 parse_func = truecrypt_parse_hash_2k;
8865 sort_by_digest = sort_by_digest_4_5;
8866 opti_type = OPTI_TYPE_ZERO_BYTE;
8867 dgst_pos0 = 0;
8868 dgst_pos1 = 1;
8869 dgst_pos2 = 2;
8870 dgst_pos3 = 3;
8871 break;
8872
8873 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8874 salt_type = SALT_TYPE_EMBEDDED;
8875 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8876 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8877 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8878 dgst_size = DGST_SIZE_4_5;
8879 parse_func = truecrypt_parse_hash_2k;
8880 sort_by_digest = sort_by_digest_4_5;
8881 opti_type = OPTI_TYPE_ZERO_BYTE;
8882 dgst_pos0 = 0;
8883 dgst_pos1 = 1;
8884 dgst_pos2 = 2;
8885 dgst_pos3 = 3;
8886 break;
8887
8888 case 6221: hash_type = HASH_TYPE_SHA512;
8889 salt_type = SALT_TYPE_EMBEDDED;
8890 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8891 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8892 kern_type = KERN_TYPE_TCSHA512_XTS512;
8893 dgst_size = DGST_SIZE_8_8;
8894 parse_func = truecrypt_parse_hash_1k;
8895 sort_by_digest = sort_by_digest_8_8;
8896 opti_type = OPTI_TYPE_ZERO_BYTE
8897 | OPTI_TYPE_USES_BITS_64;
8898 dgst_pos0 = 0;
8899 dgst_pos1 = 1;
8900 dgst_pos2 = 2;
8901 dgst_pos3 = 3;
8902 break;
8903
8904 case 6222: hash_type = HASH_TYPE_SHA512;
8905 salt_type = SALT_TYPE_EMBEDDED;
8906 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8907 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8908 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8909 dgst_size = DGST_SIZE_8_8;
8910 parse_func = truecrypt_parse_hash_1k;
8911 sort_by_digest = sort_by_digest_8_8;
8912 opti_type = OPTI_TYPE_ZERO_BYTE
8913 | OPTI_TYPE_USES_BITS_64;
8914 dgst_pos0 = 0;
8915 dgst_pos1 = 1;
8916 dgst_pos2 = 2;
8917 dgst_pos3 = 3;
8918 break;
8919
8920 case 6223: hash_type = HASH_TYPE_SHA512;
8921 salt_type = SALT_TYPE_EMBEDDED;
8922 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8923 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8924 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8925 dgst_size = DGST_SIZE_8_8;
8926 parse_func = truecrypt_parse_hash_1k;
8927 sort_by_digest = sort_by_digest_8_8;
8928 opti_type = OPTI_TYPE_ZERO_BYTE
8929 | OPTI_TYPE_USES_BITS_64;
8930 dgst_pos0 = 0;
8931 dgst_pos1 = 1;
8932 dgst_pos2 = 2;
8933 dgst_pos3 = 3;
8934 break;
8935
8936 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8937 salt_type = SALT_TYPE_EMBEDDED;
8938 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8939 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8940 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8941 dgst_size = DGST_SIZE_4_8;
8942 parse_func = truecrypt_parse_hash_1k;
8943 sort_by_digest = sort_by_digest_4_8;
8944 opti_type = OPTI_TYPE_ZERO_BYTE;
8945 dgst_pos0 = 0;
8946 dgst_pos1 = 1;
8947 dgst_pos2 = 2;
8948 dgst_pos3 = 3;
8949 break;
8950
8951 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8952 salt_type = SALT_TYPE_EMBEDDED;
8953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8954 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8955 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8956 dgst_size = DGST_SIZE_4_8;
8957 parse_func = truecrypt_parse_hash_1k;
8958 sort_by_digest = sort_by_digest_4_8;
8959 opti_type = OPTI_TYPE_ZERO_BYTE;
8960 dgst_pos0 = 0;
8961 dgst_pos1 = 1;
8962 dgst_pos2 = 2;
8963 dgst_pos3 = 3;
8964 break;
8965
8966 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8967 salt_type = SALT_TYPE_EMBEDDED;
8968 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8969 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8970 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8971 dgst_size = DGST_SIZE_4_8;
8972 parse_func = truecrypt_parse_hash_1k;
8973 sort_by_digest = sort_by_digest_4_8;
8974 opti_type = OPTI_TYPE_ZERO_BYTE;
8975 dgst_pos0 = 0;
8976 dgst_pos1 = 1;
8977 dgst_pos2 = 2;
8978 dgst_pos3 = 3;
8979 break;
8980
8981 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8982 salt_type = SALT_TYPE_EMBEDDED;
8983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8984 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8985 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8986 dgst_size = DGST_SIZE_4_5;
8987 parse_func = truecrypt_parse_hash_1k;
8988 sort_by_digest = sort_by_digest_4_5;
8989 opti_type = OPTI_TYPE_ZERO_BYTE;
8990 dgst_pos0 = 0;
8991 dgst_pos1 = 1;
8992 dgst_pos2 = 2;
8993 dgst_pos3 = 3;
8994 break;
8995
8996 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8997 salt_type = SALT_TYPE_EMBEDDED;
8998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8999 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9000 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9001 dgst_size = DGST_SIZE_4_5;
9002 parse_func = truecrypt_parse_hash_1k;
9003 sort_by_digest = sort_by_digest_4_5;
9004 opti_type = OPTI_TYPE_ZERO_BYTE;
9005 dgst_pos0 = 0;
9006 dgst_pos1 = 1;
9007 dgst_pos2 = 2;
9008 dgst_pos3 = 3;
9009 break;
9010
9011 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9012 salt_type = SALT_TYPE_EMBEDDED;
9013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9014 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9015 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9016 dgst_size = DGST_SIZE_4_5;
9017 parse_func = truecrypt_parse_hash_1k;
9018 sort_by_digest = sort_by_digest_4_5;
9019 opti_type = OPTI_TYPE_ZERO_BYTE;
9020 dgst_pos0 = 0;
9021 dgst_pos1 = 1;
9022 dgst_pos2 = 2;
9023 dgst_pos3 = 3;
9024 break;
9025
9026 case 6300: hash_type = HASH_TYPE_MD5;
9027 salt_type = SALT_TYPE_EMBEDDED;
9028 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9029 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9030 kern_type = KERN_TYPE_MD5AIX;
9031 dgst_size = DGST_SIZE_4_4;
9032 parse_func = md5aix_parse_hash;
9033 sort_by_digest = sort_by_digest_4_4;
9034 opti_type = OPTI_TYPE_ZERO_BYTE;
9035 dgst_pos0 = 0;
9036 dgst_pos1 = 1;
9037 dgst_pos2 = 2;
9038 dgst_pos3 = 3;
9039 break;
9040
9041 case 6400: hash_type = HASH_TYPE_SHA256;
9042 salt_type = SALT_TYPE_EMBEDDED;
9043 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9044 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9045 kern_type = KERN_TYPE_SHA256AIX;
9046 dgst_size = DGST_SIZE_4_8;
9047 parse_func = sha256aix_parse_hash;
9048 sort_by_digest = sort_by_digest_4_8;
9049 opti_type = OPTI_TYPE_ZERO_BYTE;
9050 dgst_pos0 = 0;
9051 dgst_pos1 = 1;
9052 dgst_pos2 = 2;
9053 dgst_pos3 = 3;
9054 break;
9055
9056 case 6500: hash_type = HASH_TYPE_SHA512;
9057 salt_type = SALT_TYPE_EMBEDDED;
9058 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9059 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9060 kern_type = KERN_TYPE_SHA512AIX;
9061 dgst_size = DGST_SIZE_8_8;
9062 parse_func = sha512aix_parse_hash;
9063 sort_by_digest = sort_by_digest_8_8;
9064 opti_type = OPTI_TYPE_ZERO_BYTE
9065 | OPTI_TYPE_USES_BITS_64;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 1;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 3;
9070 break;
9071
9072 case 6600: hash_type = HASH_TYPE_AES;
9073 salt_type = SALT_TYPE_EMBEDDED;
9074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9075 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9076 kern_type = KERN_TYPE_AGILEKEY;
9077 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9078 parse_func = agilekey_parse_hash;
9079 sort_by_digest = sort_by_digest_4_5;
9080 opti_type = OPTI_TYPE_ZERO_BYTE;
9081 dgst_pos0 = 0;
9082 dgst_pos1 = 1;
9083 dgst_pos2 = 2;
9084 dgst_pos3 = 3;
9085 break;
9086
9087 case 6700: hash_type = HASH_TYPE_SHA1;
9088 salt_type = SALT_TYPE_EMBEDDED;
9089 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9090 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9091 kern_type = KERN_TYPE_SHA1AIX;
9092 dgst_size = DGST_SIZE_4_5;
9093 parse_func = sha1aix_parse_hash;
9094 sort_by_digest = sort_by_digest_4_5;
9095 opti_type = OPTI_TYPE_ZERO_BYTE;
9096 dgst_pos0 = 0;
9097 dgst_pos1 = 1;
9098 dgst_pos2 = 2;
9099 dgst_pos3 = 3;
9100 break;
9101
9102 case 6800: hash_type = HASH_TYPE_AES;
9103 salt_type = SALT_TYPE_EMBEDDED;
9104 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9105 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9106 kern_type = KERN_TYPE_LASTPASS;
9107 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9108 parse_func = lastpass_parse_hash;
9109 sort_by_digest = sort_by_digest_4_8;
9110 opti_type = OPTI_TYPE_ZERO_BYTE;
9111 dgst_pos0 = 0;
9112 dgst_pos1 = 1;
9113 dgst_pos2 = 2;
9114 dgst_pos3 = 3;
9115 break;
9116
9117 case 6900: hash_type = HASH_TYPE_GOST;
9118 salt_type = SALT_TYPE_NONE;
9119 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9120 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9121 kern_type = KERN_TYPE_GOST;
9122 dgst_size = DGST_SIZE_4_8;
9123 parse_func = gost_parse_hash;
9124 sort_by_digest = sort_by_digest_4_8;
9125 opti_type = OPTI_TYPE_ZERO_BYTE;
9126 dgst_pos0 = 0;
9127 dgst_pos1 = 1;
9128 dgst_pos2 = 2;
9129 dgst_pos3 = 3;
9130 break;
9131
9132 case 7100: hash_type = HASH_TYPE_SHA512;
9133 salt_type = SALT_TYPE_EMBEDDED;
9134 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9135 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9136 kern_type = KERN_TYPE_PBKDF2_SHA512;
9137 dgst_size = DGST_SIZE_8_16;
9138 parse_func = sha512osx_parse_hash;
9139 sort_by_digest = sort_by_digest_8_16;
9140 opti_type = OPTI_TYPE_ZERO_BYTE
9141 | OPTI_TYPE_USES_BITS_64;
9142 dgst_pos0 = 0;
9143 dgst_pos1 = 1;
9144 dgst_pos2 = 2;
9145 dgst_pos3 = 3;
9146 break;
9147
9148 case 7200: hash_type = HASH_TYPE_SHA512;
9149 salt_type = SALT_TYPE_EMBEDDED;
9150 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9151 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9152 kern_type = KERN_TYPE_PBKDF2_SHA512;
9153 dgst_size = DGST_SIZE_8_16;
9154 parse_func = sha512grub_parse_hash;
9155 sort_by_digest = sort_by_digest_8_16;
9156 opti_type = OPTI_TYPE_ZERO_BYTE
9157 | OPTI_TYPE_USES_BITS_64;
9158 dgst_pos0 = 0;
9159 dgst_pos1 = 1;
9160 dgst_pos2 = 2;
9161 dgst_pos3 = 3;
9162 break;
9163
9164 case 7300: hash_type = HASH_TYPE_SHA1;
9165 salt_type = SALT_TYPE_EMBEDDED;
9166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9167 opts_type = OPTS_TYPE_PT_GENERATE_BE
9168 | OPTS_TYPE_ST_ADD80
9169 | OPTS_TYPE_ST_ADDBITS15;
9170 kern_type = KERN_TYPE_RAKP;
9171 dgst_size = DGST_SIZE_4_5;
9172 parse_func = rakp_parse_hash;
9173 sort_by_digest = sort_by_digest_4_5;
9174 opti_type = OPTI_TYPE_ZERO_BYTE
9175 | OPTI_TYPE_NOT_ITERATED;
9176 dgst_pos0 = 3;
9177 dgst_pos1 = 4;
9178 dgst_pos2 = 2;
9179 dgst_pos3 = 1;
9180 break;
9181
9182 case 7400: hash_type = HASH_TYPE_SHA256;
9183 salt_type = SALT_TYPE_EMBEDDED;
9184 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9185 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9186 kern_type = KERN_TYPE_SHA256CRYPT;
9187 dgst_size = DGST_SIZE_4_8;
9188 parse_func = sha256crypt_parse_hash;
9189 sort_by_digest = sort_by_digest_4_8;
9190 opti_type = OPTI_TYPE_ZERO_BYTE;
9191 dgst_pos0 = 0;
9192 dgst_pos1 = 1;
9193 dgst_pos2 = 2;
9194 dgst_pos3 = 3;
9195 break;
9196
9197 case 7500: hash_type = HASH_TYPE_KRB5PA;
9198 salt_type = SALT_TYPE_EMBEDDED;
9199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9200 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9201 kern_type = KERN_TYPE_KRB5PA;
9202 dgst_size = DGST_SIZE_4_4;
9203 parse_func = krb5pa_parse_hash;
9204 sort_by_digest = sort_by_digest_4_4;
9205 opti_type = OPTI_TYPE_ZERO_BYTE
9206 | OPTI_TYPE_NOT_ITERATED;
9207 dgst_pos0 = 0;
9208 dgst_pos1 = 1;
9209 dgst_pos2 = 2;
9210 dgst_pos3 = 3;
9211 break;
9212
9213 case 7600: hash_type = HASH_TYPE_SHA1;
9214 salt_type = SALT_TYPE_INTERN;
9215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9216 opts_type = OPTS_TYPE_PT_GENERATE_BE
9217 | OPTS_TYPE_PT_ADD80
9218 | OPTS_TYPE_PT_ADDBITS15;
9219 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9220 dgst_size = DGST_SIZE_4_5;
9221 parse_func = redmine_parse_hash;
9222 sort_by_digest = sort_by_digest_4_5;
9223 opti_type = OPTI_TYPE_ZERO_BYTE
9224 | OPTI_TYPE_PRECOMPUTE_INIT
9225 | OPTI_TYPE_EARLY_SKIP
9226 | OPTI_TYPE_NOT_ITERATED
9227 | OPTI_TYPE_PREPENDED_SALT;
9228 dgst_pos0 = 3;
9229 dgst_pos1 = 4;
9230 dgst_pos2 = 2;
9231 dgst_pos3 = 1;
9232 break;
9233
9234 case 7700: hash_type = HASH_TYPE_SAPB;
9235 salt_type = SALT_TYPE_EMBEDDED;
9236 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9237 opts_type = OPTS_TYPE_PT_GENERATE_LE
9238 | OPTS_TYPE_PT_UPPER
9239 | OPTS_TYPE_ST_UPPER;
9240 kern_type = KERN_TYPE_SAPB;
9241 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9242 parse_func = sapb_parse_hash;
9243 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9244 opti_type = OPTI_TYPE_ZERO_BYTE
9245 | OPTI_TYPE_PRECOMPUTE_INIT
9246 | OPTI_TYPE_NOT_ITERATED;
9247 dgst_pos0 = 0;
9248 dgst_pos1 = 1;
9249 dgst_pos2 = 2;
9250 dgst_pos3 = 3;
9251 break;
9252
9253 case 7800: hash_type = HASH_TYPE_SAPG;
9254 salt_type = SALT_TYPE_EMBEDDED;
9255 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9256 opts_type = OPTS_TYPE_PT_GENERATE_BE
9257 | OPTS_TYPE_ST_ADD80
9258 | OPTS_TYPE_ST_UPPER;
9259 kern_type = KERN_TYPE_SAPG;
9260 dgst_size = DGST_SIZE_4_5;
9261 parse_func = sapg_parse_hash;
9262 sort_by_digest = sort_by_digest_4_5;
9263 opti_type = OPTI_TYPE_ZERO_BYTE
9264 | OPTI_TYPE_PRECOMPUTE_INIT
9265 | OPTI_TYPE_NOT_ITERATED;
9266 dgst_pos0 = 3;
9267 dgst_pos1 = 4;
9268 dgst_pos2 = 2;
9269 dgst_pos3 = 1;
9270 break;
9271
9272 case 7900: hash_type = HASH_TYPE_SHA512;
9273 salt_type = SALT_TYPE_EMBEDDED;
9274 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9275 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9276 kern_type = KERN_TYPE_DRUPAL7;
9277 dgst_size = DGST_SIZE_8_8;
9278 parse_func = drupal7_parse_hash;
9279 sort_by_digest = sort_by_digest_8_8;
9280 opti_type = OPTI_TYPE_ZERO_BYTE
9281 | OPTI_TYPE_USES_BITS_64;
9282 dgst_pos0 = 0;
9283 dgst_pos1 = 1;
9284 dgst_pos2 = 2;
9285 dgst_pos3 = 3;
9286 break;
9287
9288 case 8000: hash_type = HASH_TYPE_SHA256;
9289 salt_type = SALT_TYPE_EMBEDDED;
9290 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9291 opts_type = OPTS_TYPE_PT_GENERATE_BE
9292 | OPTS_TYPE_PT_UNICODE
9293 | OPTS_TYPE_ST_ADD80
9294 | OPTS_TYPE_ST_HEX;
9295 kern_type = KERN_TYPE_SYBASEASE;
9296 dgst_size = DGST_SIZE_4_8;
9297 parse_func = sybasease_parse_hash;
9298 sort_by_digest = sort_by_digest_4_8;
9299 opti_type = OPTI_TYPE_ZERO_BYTE
9300 | OPTI_TYPE_PRECOMPUTE_INIT
9301 | OPTI_TYPE_EARLY_SKIP
9302 | OPTI_TYPE_NOT_ITERATED
9303 | OPTI_TYPE_RAW_HASH;
9304 dgst_pos0 = 3;
9305 dgst_pos1 = 7;
9306 dgst_pos2 = 2;
9307 dgst_pos3 = 6;
9308 break;
9309
9310 case 8100: hash_type = HASH_TYPE_SHA1;
9311 salt_type = SALT_TYPE_EMBEDDED;
9312 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9313 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9314 kern_type = KERN_TYPE_NETSCALER;
9315 dgst_size = DGST_SIZE_4_5;
9316 parse_func = netscaler_parse_hash;
9317 sort_by_digest = sort_by_digest_4_5;
9318 opti_type = OPTI_TYPE_ZERO_BYTE
9319 | OPTI_TYPE_PRECOMPUTE_INIT
9320 | OPTI_TYPE_PRECOMPUTE_MERKLE
9321 | OPTI_TYPE_EARLY_SKIP
9322 | OPTI_TYPE_NOT_ITERATED
9323 | OPTI_TYPE_PREPENDED_SALT
9324 | OPTI_TYPE_RAW_HASH;
9325 dgst_pos0 = 3;
9326 dgst_pos1 = 4;
9327 dgst_pos2 = 2;
9328 dgst_pos3 = 1;
9329 break;
9330
9331 case 8200: hash_type = HASH_TYPE_SHA256;
9332 salt_type = SALT_TYPE_EMBEDDED;
9333 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9334 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9335 kern_type = KERN_TYPE_CLOUDKEY;
9336 dgst_size = DGST_SIZE_4_8;
9337 parse_func = cloudkey_parse_hash;
9338 sort_by_digest = sort_by_digest_4_8;
9339 opti_type = OPTI_TYPE_ZERO_BYTE;
9340 dgst_pos0 = 0;
9341 dgst_pos1 = 1;
9342 dgst_pos2 = 2;
9343 dgst_pos3 = 3;
9344 break;
9345
9346 case 8300: hash_type = HASH_TYPE_SHA1;
9347 salt_type = SALT_TYPE_EMBEDDED;
9348 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9349 opts_type = OPTS_TYPE_PT_GENERATE_BE
9350 | OPTS_TYPE_ST_HEX
9351 | OPTS_TYPE_ST_ADD80;
9352 kern_type = KERN_TYPE_NSEC3;
9353 dgst_size = DGST_SIZE_4_5;
9354 parse_func = nsec3_parse_hash;
9355 sort_by_digest = sort_by_digest_4_5;
9356 opti_type = OPTI_TYPE_ZERO_BYTE;
9357 dgst_pos0 = 3;
9358 dgst_pos1 = 4;
9359 dgst_pos2 = 2;
9360 dgst_pos3 = 1;
9361 break;
9362
9363 case 8400: hash_type = HASH_TYPE_SHA1;
9364 salt_type = SALT_TYPE_INTERN;
9365 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9366 opts_type = OPTS_TYPE_PT_GENERATE_BE
9367 | OPTS_TYPE_PT_ADD80
9368 | OPTS_TYPE_PT_ADDBITS15;
9369 kern_type = KERN_TYPE_WBB3;
9370 dgst_size = DGST_SIZE_4_5;
9371 parse_func = wbb3_parse_hash;
9372 sort_by_digest = sort_by_digest_4_5;
9373 opti_type = OPTI_TYPE_ZERO_BYTE
9374 | OPTI_TYPE_PRECOMPUTE_INIT
9375 | OPTI_TYPE_NOT_ITERATED;
9376 dgst_pos0 = 3;
9377 dgst_pos1 = 4;
9378 dgst_pos2 = 2;
9379 dgst_pos3 = 1;
9380 break;
9381
9382 case 8500: hash_type = HASH_TYPE_DESRACF;
9383 salt_type = SALT_TYPE_EMBEDDED;
9384 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9385 opts_type = OPTS_TYPE_PT_GENERATE_LE
9386 | OPTS_TYPE_ST_UPPER;
9387 kern_type = KERN_TYPE_RACF;
9388 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9389 parse_func = racf_parse_hash;
9390 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9391 opti_type = OPTI_TYPE_ZERO_BYTE
9392 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9393 dgst_pos0 = 0;
9394 dgst_pos1 = 1;
9395 dgst_pos2 = 2;
9396 dgst_pos3 = 3;
9397 break;
9398
9399 case 8600: hash_type = HASH_TYPE_LOTUS5;
9400 salt_type = SALT_TYPE_NONE;
9401 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9402 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9403 kern_type = KERN_TYPE_LOTUS5;
9404 dgst_size = DGST_SIZE_4_4;
9405 parse_func = lotus5_parse_hash;
9406 sort_by_digest = sort_by_digest_4_4;
9407 opti_type = OPTI_TYPE_EARLY_SKIP
9408 | OPTI_TYPE_NOT_ITERATED
9409 | OPTI_TYPE_NOT_SALTED
9410 | OPTI_TYPE_RAW_HASH;
9411 dgst_pos0 = 0;
9412 dgst_pos1 = 1;
9413 dgst_pos2 = 2;
9414 dgst_pos3 = 3;
9415 break;
9416
9417 case 8700: hash_type = HASH_TYPE_LOTUS6;
9418 salt_type = SALT_TYPE_EMBEDDED;
9419 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9420 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9421 kern_type = KERN_TYPE_LOTUS6;
9422 dgst_size = DGST_SIZE_4_4;
9423 parse_func = lotus6_parse_hash;
9424 sort_by_digest = sort_by_digest_4_4;
9425 opti_type = OPTI_TYPE_EARLY_SKIP
9426 | OPTI_TYPE_NOT_ITERATED
9427 | OPTI_TYPE_RAW_HASH;
9428 dgst_pos0 = 0;
9429 dgst_pos1 = 1;
9430 dgst_pos2 = 2;
9431 dgst_pos3 = 3;
9432 break;
9433
9434 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9435 salt_type = SALT_TYPE_EMBEDDED;
9436 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9437 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9438 kern_type = KERN_TYPE_ANDROIDFDE;
9439 dgst_size = DGST_SIZE_4_4;
9440 parse_func = androidfde_parse_hash;
9441 sort_by_digest = sort_by_digest_4_4;
9442 opti_type = OPTI_TYPE_ZERO_BYTE;
9443 dgst_pos0 = 0;
9444 dgst_pos1 = 1;
9445 dgst_pos2 = 2;
9446 dgst_pos3 = 3;
9447 break;
9448
9449 case 8900: hash_type = HASH_TYPE_SCRYPT;
9450 salt_type = SALT_TYPE_EMBEDDED;
9451 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9452 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9453 kern_type = KERN_TYPE_SCRYPT;
9454 dgst_size = DGST_SIZE_4_8;
9455 parse_func = scrypt_parse_hash;
9456 sort_by_digest = sort_by_digest_4_8;
9457 opti_type = OPTI_TYPE_ZERO_BYTE;
9458 dgst_pos0 = 0;
9459 dgst_pos1 = 1;
9460 dgst_pos2 = 2;
9461 dgst_pos3 = 3;
9462 break;
9463
9464 case 9000: hash_type = HASH_TYPE_SHA1;
9465 salt_type = SALT_TYPE_EMBEDDED;
9466 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9467 opts_type = OPTS_TYPE_PT_GENERATE_LE
9468 | OPTS_TYPE_ST_GENERATE_LE;
9469 kern_type = KERN_TYPE_PSAFE2;
9470 dgst_size = DGST_SIZE_4_5;
9471 parse_func = psafe2_parse_hash;
9472 sort_by_digest = sort_by_digest_4_5;
9473 opti_type = OPTI_TYPE_ZERO_BYTE;
9474 dgst_pos0 = 0;
9475 dgst_pos1 = 1;
9476 dgst_pos2 = 2;
9477 dgst_pos3 = 3;
9478 break;
9479
9480 case 9100: hash_type = HASH_TYPE_LOTUS8;
9481 salt_type = SALT_TYPE_EMBEDDED;
9482 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9483 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9484 kern_type = KERN_TYPE_LOTUS8;
9485 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9486 parse_func = lotus8_parse_hash;
9487 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9488 opti_type = OPTI_TYPE_ZERO_BYTE;
9489 dgst_pos0 = 0;
9490 dgst_pos1 = 1;
9491 dgst_pos2 = 2;
9492 dgst_pos3 = 3;
9493 break;
9494
9495 case 9200: hash_type = HASH_TYPE_SHA256;
9496 salt_type = SALT_TYPE_EMBEDDED;
9497 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9498 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9499 kern_type = KERN_TYPE_PBKDF2_SHA256;
9500 dgst_size = DGST_SIZE_4_32;
9501 parse_func = cisco8_parse_hash;
9502 sort_by_digest = sort_by_digest_4_32;
9503 opti_type = OPTI_TYPE_ZERO_BYTE;
9504 dgst_pos0 = 0;
9505 dgst_pos1 = 1;
9506 dgst_pos2 = 2;
9507 dgst_pos3 = 3;
9508 break;
9509
9510 case 9300: hash_type = HASH_TYPE_SCRYPT;
9511 salt_type = SALT_TYPE_EMBEDDED;
9512 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9513 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9514 kern_type = KERN_TYPE_SCRYPT;
9515 dgst_size = DGST_SIZE_4_8;
9516 parse_func = cisco9_parse_hash;
9517 sort_by_digest = sort_by_digest_4_8;
9518 opti_type = OPTI_TYPE_ZERO_BYTE;
9519 dgst_pos0 = 0;
9520 dgst_pos1 = 1;
9521 dgst_pos2 = 2;
9522 dgst_pos3 = 3;
9523 break;
9524
9525 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9526 salt_type = SALT_TYPE_EMBEDDED;
9527 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9528 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9529 kern_type = KERN_TYPE_OFFICE2007;
9530 dgst_size = DGST_SIZE_4_4;
9531 parse_func = office2007_parse_hash;
9532 sort_by_digest = sort_by_digest_4_4;
9533 opti_type = OPTI_TYPE_ZERO_BYTE;
9534 dgst_pos0 = 0;
9535 dgst_pos1 = 1;
9536 dgst_pos2 = 2;
9537 dgst_pos3 = 3;
9538 break;
9539
9540 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9541 salt_type = SALT_TYPE_EMBEDDED;
9542 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9543 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9544 kern_type = KERN_TYPE_OFFICE2010;
9545 dgst_size = DGST_SIZE_4_4;
9546 parse_func = office2010_parse_hash;
9547 sort_by_digest = sort_by_digest_4_4;
9548 opti_type = OPTI_TYPE_ZERO_BYTE;
9549 dgst_pos0 = 0;
9550 dgst_pos1 = 1;
9551 dgst_pos2 = 2;
9552 dgst_pos3 = 3;
9553 break;
9554
9555 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9556 salt_type = SALT_TYPE_EMBEDDED;
9557 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9558 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9559 kern_type = KERN_TYPE_OFFICE2013;
9560 dgst_size = DGST_SIZE_4_4;
9561 parse_func = office2013_parse_hash;
9562 sort_by_digest = sort_by_digest_4_4;
9563 opti_type = OPTI_TYPE_ZERO_BYTE;
9564 dgst_pos0 = 0;
9565 dgst_pos1 = 1;
9566 dgst_pos2 = 2;
9567 dgst_pos3 = 3;
9568 break;
9569
9570 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9571 salt_type = SALT_TYPE_EMBEDDED;
9572 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9573 opts_type = OPTS_TYPE_PT_GENERATE_LE
9574 | OPTS_TYPE_PT_ADD80
9575 | OPTS_TYPE_PT_UNICODE;
9576 kern_type = KERN_TYPE_OLDOFFICE01;
9577 dgst_size = DGST_SIZE_4_4;
9578 parse_func = oldoffice01_parse_hash;
9579 sort_by_digest = sort_by_digest_4_4;
9580 opti_type = OPTI_TYPE_ZERO_BYTE
9581 | OPTI_TYPE_PRECOMPUTE_INIT
9582 | OPTI_TYPE_NOT_ITERATED;
9583 dgst_pos0 = 0;
9584 dgst_pos1 = 1;
9585 dgst_pos2 = 2;
9586 dgst_pos3 = 3;
9587 break;
9588
9589 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9590 salt_type = SALT_TYPE_EMBEDDED;
9591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9592 opts_type = OPTS_TYPE_PT_GENERATE_LE
9593 | OPTS_TYPE_PT_ADD80;
9594 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9595 dgst_size = DGST_SIZE_4_4;
9596 parse_func = oldoffice01cm1_parse_hash;
9597 sort_by_digest = sort_by_digest_4_4;
9598 opti_type = OPTI_TYPE_ZERO_BYTE
9599 | OPTI_TYPE_PRECOMPUTE_INIT
9600 | OPTI_TYPE_NOT_ITERATED;
9601 dgst_pos0 = 0;
9602 dgst_pos1 = 1;
9603 dgst_pos2 = 2;
9604 dgst_pos3 = 3;
9605 break;
9606
9607 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9608 salt_type = SALT_TYPE_EMBEDDED;
9609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9610 opts_type = OPTS_TYPE_PT_GENERATE_LE
9611 | OPTS_TYPE_PT_ADD80
9612 | OPTS_TYPE_PT_UNICODE
9613 | OPTS_TYPE_PT_NEVERCRACK;
9614 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9615 dgst_size = DGST_SIZE_4_4;
9616 parse_func = oldoffice01cm2_parse_hash;
9617 sort_by_digest = sort_by_digest_4_4;
9618 opti_type = OPTI_TYPE_ZERO_BYTE
9619 | OPTI_TYPE_PRECOMPUTE_INIT
9620 | OPTI_TYPE_NOT_ITERATED;
9621 dgst_pos0 = 0;
9622 dgst_pos1 = 1;
9623 dgst_pos2 = 2;
9624 dgst_pos3 = 3;
9625 break;
9626
9627 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9628 salt_type = SALT_TYPE_EMBEDDED;
9629 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9630 opts_type = OPTS_TYPE_PT_GENERATE_BE
9631 | OPTS_TYPE_PT_ADD80
9632 | OPTS_TYPE_PT_UNICODE;
9633 kern_type = KERN_TYPE_OLDOFFICE34;
9634 dgst_size = DGST_SIZE_4_4;
9635 parse_func = oldoffice34_parse_hash;
9636 sort_by_digest = sort_by_digest_4_4;
9637 opti_type = OPTI_TYPE_ZERO_BYTE
9638 | OPTI_TYPE_PRECOMPUTE_INIT
9639 | OPTI_TYPE_NOT_ITERATED;
9640 dgst_pos0 = 0;
9641 dgst_pos1 = 1;
9642 dgst_pos2 = 2;
9643 dgst_pos3 = 3;
9644 break;
9645
9646 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9647 salt_type = SALT_TYPE_EMBEDDED;
9648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9649 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9650 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9651 dgst_size = DGST_SIZE_4_4;
9652 parse_func = oldoffice34cm1_parse_hash;
9653 sort_by_digest = sort_by_digest_4_4;
9654 opti_type = OPTI_TYPE_ZERO_BYTE
9655 | OPTI_TYPE_PRECOMPUTE_INIT
9656 | OPTI_TYPE_NOT_ITERATED;
9657 dgst_pos0 = 0;
9658 dgst_pos1 = 1;
9659 dgst_pos2 = 2;
9660 dgst_pos3 = 3;
9661 break;
9662
9663 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9664 salt_type = SALT_TYPE_EMBEDDED;
9665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9666 opts_type = OPTS_TYPE_PT_GENERATE_BE
9667 | OPTS_TYPE_PT_ADD80
9668 | OPTS_TYPE_PT_UNICODE
9669 | OPTS_TYPE_PT_NEVERCRACK;
9670 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9671 dgst_size = DGST_SIZE_4_4;
9672 parse_func = oldoffice34cm2_parse_hash;
9673 sort_by_digest = sort_by_digest_4_4;
9674 opti_type = OPTI_TYPE_ZERO_BYTE
9675 | OPTI_TYPE_PRECOMPUTE_INIT
9676 | OPTI_TYPE_NOT_ITERATED;
9677 dgst_pos0 = 0;
9678 dgst_pos1 = 1;
9679 dgst_pos2 = 2;
9680 dgst_pos3 = 3;
9681 break;
9682
9683 case 9900: hash_type = HASH_TYPE_MD5;
9684 salt_type = SALT_TYPE_NONE;
9685 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9686 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9687 kern_type = KERN_TYPE_RADMIN2;
9688 dgst_size = DGST_SIZE_4_4;
9689 parse_func = radmin2_parse_hash;
9690 sort_by_digest = sort_by_digest_4_4;
9691 opti_type = OPTI_TYPE_ZERO_BYTE
9692 | OPTI_TYPE_PRECOMPUTE_INIT
9693 | OPTI_TYPE_EARLY_SKIP
9694 | OPTI_TYPE_NOT_ITERATED
9695 | OPTI_TYPE_NOT_SALTED;
9696 dgst_pos0 = 0;
9697 dgst_pos1 = 3;
9698 dgst_pos2 = 2;
9699 dgst_pos3 = 1;
9700 break;
9701
9702 case 10000: hash_type = HASH_TYPE_SHA256;
9703 salt_type = SALT_TYPE_EMBEDDED;
9704 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9705 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9706 kern_type = KERN_TYPE_PBKDF2_SHA256;
9707 dgst_size = DGST_SIZE_4_32;
9708 parse_func = djangopbkdf2_parse_hash;
9709 sort_by_digest = sort_by_digest_4_32;
9710 opti_type = OPTI_TYPE_ZERO_BYTE;
9711 dgst_pos0 = 0;
9712 dgst_pos1 = 1;
9713 dgst_pos2 = 2;
9714 dgst_pos3 = 3;
9715 break;
9716
9717 case 10100: hash_type = HASH_TYPE_SIPHASH;
9718 salt_type = SALT_TYPE_EMBEDDED;
9719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9720 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9721 kern_type = KERN_TYPE_SIPHASH;
9722 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9723 parse_func = siphash_parse_hash;
9724 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9725 opti_type = OPTI_TYPE_ZERO_BYTE
9726 | OPTI_TYPE_NOT_ITERATED
9727 | OPTI_TYPE_RAW_HASH;
9728 dgst_pos0 = 0;
9729 dgst_pos1 = 1;
9730 dgst_pos2 = 2;
9731 dgst_pos3 = 3;
9732 break;
9733
9734 case 10200: hash_type = HASH_TYPE_MD5;
9735 salt_type = SALT_TYPE_EMBEDDED;
9736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9737 opts_type = OPTS_TYPE_PT_GENERATE_LE
9738 | OPTS_TYPE_ST_ADD80
9739 | OPTS_TYPE_ST_ADDBITS14;
9740 kern_type = KERN_TYPE_HMACMD5_PW;
9741 dgst_size = DGST_SIZE_4_4;
9742 parse_func = crammd5_parse_hash;
9743 sort_by_digest = sort_by_digest_4_4;
9744 opti_type = OPTI_TYPE_ZERO_BYTE
9745 | OPTI_TYPE_NOT_ITERATED;
9746 dgst_pos0 = 0;
9747 dgst_pos1 = 3;
9748 dgst_pos2 = 2;
9749 dgst_pos3 = 1;
9750 break;
9751
9752 case 10300: hash_type = HASH_TYPE_SHA1;
9753 salt_type = SALT_TYPE_EMBEDDED;
9754 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9755 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9756 kern_type = KERN_TYPE_SAPH_SHA1;
9757 dgst_size = DGST_SIZE_4_5;
9758 parse_func = saph_sha1_parse_hash;
9759 sort_by_digest = sort_by_digest_4_5;
9760 opti_type = OPTI_TYPE_ZERO_BYTE;
9761 dgst_pos0 = 0;
9762 dgst_pos1 = 1;
9763 dgst_pos2 = 2;
9764 dgst_pos3 = 3;
9765 break;
9766
9767 case 10400: hash_type = HASH_TYPE_PDFU16;
9768 salt_type = SALT_TYPE_EMBEDDED;
9769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9770 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9771 kern_type = KERN_TYPE_PDF11;
9772 dgst_size = DGST_SIZE_4_4;
9773 parse_func = pdf11_parse_hash;
9774 sort_by_digest = sort_by_digest_4_4;
9775 opti_type = OPTI_TYPE_ZERO_BYTE
9776 | OPTI_TYPE_NOT_ITERATED;
9777 dgst_pos0 = 0;
9778 dgst_pos1 = 1;
9779 dgst_pos2 = 2;
9780 dgst_pos3 = 3;
9781 break;
9782
9783 case 10410: hash_type = HASH_TYPE_PDFU16;
9784 salt_type = SALT_TYPE_EMBEDDED;
9785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9786 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9787 kern_type = KERN_TYPE_PDF11CM1;
9788 dgst_size = DGST_SIZE_4_4;
9789 parse_func = pdf11cm1_parse_hash;
9790 sort_by_digest = sort_by_digest_4_4;
9791 opti_type = OPTI_TYPE_ZERO_BYTE
9792 | OPTI_TYPE_NOT_ITERATED;
9793 dgst_pos0 = 0;
9794 dgst_pos1 = 1;
9795 dgst_pos2 = 2;
9796 dgst_pos3 = 3;
9797 break;
9798
9799 case 10420: hash_type = HASH_TYPE_PDFU16;
9800 salt_type = SALT_TYPE_EMBEDDED;
9801 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9802 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9803 kern_type = KERN_TYPE_PDF11CM2;
9804 dgst_size = DGST_SIZE_4_4;
9805 parse_func = pdf11cm2_parse_hash;
9806 sort_by_digest = sort_by_digest_4_4;
9807 opti_type = OPTI_TYPE_ZERO_BYTE
9808 | OPTI_TYPE_NOT_ITERATED;
9809 dgst_pos0 = 0;
9810 dgst_pos1 = 1;
9811 dgst_pos2 = 2;
9812 dgst_pos3 = 3;
9813 break;
9814
9815 case 10500: hash_type = HASH_TYPE_PDFU16;
9816 salt_type = SALT_TYPE_EMBEDDED;
9817 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9818 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9819 kern_type = KERN_TYPE_PDF14;
9820 dgst_size = DGST_SIZE_4_4;
9821 parse_func = pdf14_parse_hash;
9822 sort_by_digest = sort_by_digest_4_4;
9823 opti_type = OPTI_TYPE_ZERO_BYTE
9824 | OPTI_TYPE_NOT_ITERATED;
9825 dgst_pos0 = 0;
9826 dgst_pos1 = 1;
9827 dgst_pos2 = 2;
9828 dgst_pos3 = 3;
9829 break;
9830
9831 case 10600: hash_type = HASH_TYPE_SHA256;
9832 salt_type = SALT_TYPE_EMBEDDED;
9833 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9834 opts_type = OPTS_TYPE_PT_GENERATE_BE
9835 | OPTS_TYPE_ST_ADD80
9836 | OPTS_TYPE_ST_ADDBITS15
9837 | OPTS_TYPE_HASH_COPY;
9838 kern_type = KERN_TYPE_SHA256_PWSLT;
9839 dgst_size = DGST_SIZE_4_8;
9840 parse_func = pdf17l3_parse_hash;
9841 sort_by_digest = sort_by_digest_4_8;
9842 opti_type = OPTI_TYPE_ZERO_BYTE
9843 | OPTI_TYPE_PRECOMPUTE_INIT
9844 | OPTI_TYPE_PRECOMPUTE_MERKLE
9845 | OPTI_TYPE_EARLY_SKIP
9846 | OPTI_TYPE_NOT_ITERATED
9847 | OPTI_TYPE_APPENDED_SALT
9848 | OPTI_TYPE_RAW_HASH;
9849 dgst_pos0 = 3;
9850 dgst_pos1 = 7;
9851 dgst_pos2 = 2;
9852 dgst_pos3 = 6;
9853 break;
9854
9855 case 10700: hash_type = HASH_TYPE_PDFU32;
9856 salt_type = SALT_TYPE_EMBEDDED;
9857 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9858 opts_type = OPTS_TYPE_PT_GENERATE_LE
9859 | OPTS_TYPE_HASH_COPY;
9860 kern_type = KERN_TYPE_PDF17L8;
9861 dgst_size = DGST_SIZE_4_8;
9862 parse_func = pdf17l8_parse_hash;
9863 sort_by_digest = sort_by_digest_4_8;
9864 opti_type = OPTI_TYPE_ZERO_BYTE
9865 | OPTI_TYPE_NOT_ITERATED;
9866 dgst_pos0 = 0;
9867 dgst_pos1 = 1;
9868 dgst_pos2 = 2;
9869 dgst_pos3 = 3;
9870 break;
9871
9872 case 10800: hash_type = HASH_TYPE_SHA384;
9873 salt_type = SALT_TYPE_NONE;
9874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9875 opts_type = OPTS_TYPE_PT_GENERATE_BE
9876 | OPTS_TYPE_PT_ADD80
9877 | OPTS_TYPE_PT_ADDBITS15;
9878 kern_type = KERN_TYPE_SHA384;
9879 dgst_size = DGST_SIZE_8_8;
9880 parse_func = sha384_parse_hash;
9881 sort_by_digest = sort_by_digest_8_8;
9882 opti_type = OPTI_TYPE_ZERO_BYTE
9883 | OPTI_TYPE_PRECOMPUTE_INIT
9884 | OPTI_TYPE_PRECOMPUTE_MERKLE
9885 | OPTI_TYPE_EARLY_SKIP
9886 | OPTI_TYPE_NOT_ITERATED
9887 | OPTI_TYPE_NOT_SALTED
9888 | OPTI_TYPE_USES_BITS_64
9889 | OPTI_TYPE_RAW_HASH;
9890 dgst_pos0 = 6;
9891 dgst_pos1 = 7;
9892 dgst_pos2 = 4;
9893 dgst_pos3 = 5;
9894 break;
9895
9896 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9897 salt_type = SALT_TYPE_EMBEDDED;
9898 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9899 opts_type = OPTS_TYPE_PT_GENERATE_LE
9900 | OPTS_TYPE_ST_BASE64
9901 | OPTS_TYPE_HASH_COPY;
9902 kern_type = KERN_TYPE_PBKDF2_SHA256;
9903 dgst_size = DGST_SIZE_4_32;
9904 parse_func = pbkdf2_sha256_parse_hash;
9905 sort_by_digest = sort_by_digest_4_32;
9906 opti_type = OPTI_TYPE_ZERO_BYTE;
9907 dgst_pos0 = 0;
9908 dgst_pos1 = 1;
9909 dgst_pos2 = 2;
9910 dgst_pos3 = 3;
9911 break;
9912
9913 case 11000: hash_type = HASH_TYPE_MD5;
9914 salt_type = SALT_TYPE_INTERN;
9915 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9916 opts_type = OPTS_TYPE_PT_GENERATE_LE
9917 | OPTS_TYPE_PT_ADD80;
9918 kern_type = KERN_TYPE_PRESTASHOP;
9919 dgst_size = DGST_SIZE_4_4;
9920 parse_func = prestashop_parse_hash;
9921 sort_by_digest = sort_by_digest_4_4;
9922 opti_type = OPTI_TYPE_ZERO_BYTE
9923 | OPTI_TYPE_PRECOMPUTE_INIT
9924 | OPTI_TYPE_NOT_ITERATED
9925 | OPTI_TYPE_PREPENDED_SALT;
9926 dgst_pos0 = 0;
9927 dgst_pos1 = 3;
9928 dgst_pos2 = 2;
9929 dgst_pos3 = 1;
9930 break;
9931
9932 case 11100: hash_type = HASH_TYPE_MD5;
9933 salt_type = SALT_TYPE_EMBEDDED;
9934 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9935 opts_type = OPTS_TYPE_PT_GENERATE_LE
9936 | OPTS_TYPE_ST_ADD80;
9937 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9938 dgst_size = DGST_SIZE_4_4;
9939 parse_func = postgresql_auth_parse_hash;
9940 sort_by_digest = sort_by_digest_4_4;
9941 opti_type = OPTI_TYPE_ZERO_BYTE
9942 | OPTI_TYPE_PRECOMPUTE_INIT
9943 | OPTI_TYPE_PRECOMPUTE_MERKLE
9944 | OPTI_TYPE_EARLY_SKIP;
9945 dgst_pos0 = 0;
9946 dgst_pos1 = 3;
9947 dgst_pos2 = 2;
9948 dgst_pos3 = 1;
9949 break;
9950
9951 case 11200: hash_type = HASH_TYPE_SHA1;
9952 salt_type = SALT_TYPE_EMBEDDED;
9953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9954 opts_type = OPTS_TYPE_PT_GENERATE_BE
9955 | OPTS_TYPE_PT_ADD80
9956 | OPTS_TYPE_ST_HEX;
9957 kern_type = KERN_TYPE_MYSQL_AUTH;
9958 dgst_size = DGST_SIZE_4_5;
9959 parse_func = mysql_auth_parse_hash;
9960 sort_by_digest = sort_by_digest_4_5;
9961 opti_type = OPTI_TYPE_ZERO_BYTE
9962 | OPTI_TYPE_EARLY_SKIP;
9963 dgst_pos0 = 3;
9964 dgst_pos1 = 4;
9965 dgst_pos2 = 2;
9966 dgst_pos3 = 1;
9967 break;
9968
9969 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9970 salt_type = SALT_TYPE_EMBEDDED;
9971 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9972 opts_type = OPTS_TYPE_PT_GENERATE_LE
9973 | OPTS_TYPE_ST_HEX
9974 | OPTS_TYPE_ST_ADD80;
9975 kern_type = KERN_TYPE_BITCOIN_WALLET;
9976 dgst_size = DGST_SIZE_4_4;
9977 parse_func = bitcoin_wallet_parse_hash;
9978 sort_by_digest = sort_by_digest_4_4;
9979 opti_type = OPTI_TYPE_ZERO_BYTE;
9980 dgst_pos0 = 0;
9981 dgst_pos1 = 1;
9982 dgst_pos2 = 2;
9983 dgst_pos3 = 3;
9984 break;
9985
9986 case 11400: hash_type = HASH_TYPE_MD5;
9987 salt_type = SALT_TYPE_EMBEDDED;
9988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9989 opts_type = OPTS_TYPE_PT_GENERATE_LE
9990 | OPTS_TYPE_PT_ADD80
9991 | OPTS_TYPE_HASH_COPY;
9992 kern_type = KERN_TYPE_SIP_AUTH;
9993 dgst_size = DGST_SIZE_4_4;
9994 parse_func = sip_auth_parse_hash;
9995 sort_by_digest = sort_by_digest_4_4;
9996 opti_type = OPTI_TYPE_ZERO_BYTE;
9997 dgst_pos0 = 0;
9998 dgst_pos1 = 3;
9999 dgst_pos2 = 2;
10000 dgst_pos3 = 1;
10001 break;
10002
10003 case 11500: hash_type = HASH_TYPE_CRC32;
10004 salt_type = SALT_TYPE_INTERN;
10005 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10006 opts_type = OPTS_TYPE_PT_GENERATE_LE
10007 | OPTS_TYPE_ST_GENERATE_LE
10008 | OPTS_TYPE_ST_HEX;
10009 kern_type = KERN_TYPE_CRC32;
10010 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10011 parse_func = crc32_parse_hash;
10012 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10013 opti_type = OPTI_TYPE_ZERO_BYTE;
10014 dgst_pos0 = 0;
10015 dgst_pos1 = 1;
10016 dgst_pos2 = 2;
10017 dgst_pos3 = 3;
10018 break;
10019
10020 case 11600: hash_type = HASH_TYPE_AES;
10021 salt_type = SALT_TYPE_EMBEDDED;
10022 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10023 opts_type = OPTS_TYPE_PT_GENERATE_LE
10024 | OPTS_TYPE_PT_NEVERCRACK;
10025 kern_type = KERN_TYPE_SEVEN_ZIP;
10026 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10027 parse_func = seven_zip_parse_hash;
10028 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10029 opti_type = OPTI_TYPE_ZERO_BYTE;
10030 dgst_pos0 = 0;
10031 dgst_pos1 = 1;
10032 dgst_pos2 = 2;
10033 dgst_pos3 = 3;
10034 break;
10035
10036 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10037 salt_type = SALT_TYPE_NONE;
10038 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10039 opts_type = OPTS_TYPE_PT_GENERATE_LE
10040 | OPTS_TYPE_PT_ADD01;
10041 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10042 dgst_size = DGST_SIZE_4_8;
10043 parse_func = gost2012sbog_256_parse_hash;
10044 sort_by_digest = sort_by_digest_4_8;
10045 opti_type = OPTI_TYPE_ZERO_BYTE;
10046 dgst_pos0 = 0;
10047 dgst_pos1 = 1;
10048 dgst_pos2 = 2;
10049 dgst_pos3 = 3;
10050 break;
10051
10052 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10053 salt_type = SALT_TYPE_NONE;
10054 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10055 opts_type = OPTS_TYPE_PT_GENERATE_LE
10056 | OPTS_TYPE_PT_ADD01;
10057 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10058 dgst_size = DGST_SIZE_4_16;
10059 parse_func = gost2012sbog_512_parse_hash;
10060 sort_by_digest = sort_by_digest_4_16;
10061 opti_type = OPTI_TYPE_ZERO_BYTE;
10062 dgst_pos0 = 0;
10063 dgst_pos1 = 1;
10064 dgst_pos2 = 2;
10065 dgst_pos3 = 3;
10066 break;
10067
10068 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10069 salt_type = SALT_TYPE_EMBEDDED;
10070 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10071 opts_type = OPTS_TYPE_PT_GENERATE_LE
10072 | OPTS_TYPE_ST_BASE64
10073 | OPTS_TYPE_HASH_COPY;
10074 kern_type = KERN_TYPE_PBKDF2_MD5;
10075 dgst_size = DGST_SIZE_4_32;
10076 parse_func = pbkdf2_md5_parse_hash;
10077 sort_by_digest = sort_by_digest_4_32;
10078 opti_type = OPTI_TYPE_ZERO_BYTE;
10079 dgst_pos0 = 0;
10080 dgst_pos1 = 1;
10081 dgst_pos2 = 2;
10082 dgst_pos3 = 3;
10083 break;
10084
10085 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10086 salt_type = SALT_TYPE_EMBEDDED;
10087 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10088 opts_type = OPTS_TYPE_PT_GENERATE_LE
10089 | OPTS_TYPE_ST_BASE64
10090 | OPTS_TYPE_HASH_COPY;
10091 kern_type = KERN_TYPE_PBKDF2_SHA1;
10092 dgst_size = DGST_SIZE_4_32;
10093 parse_func = pbkdf2_sha1_parse_hash;
10094 sort_by_digest = sort_by_digest_4_32;
10095 opti_type = OPTI_TYPE_ZERO_BYTE;
10096 dgst_pos0 = 0;
10097 dgst_pos1 = 1;
10098 dgst_pos2 = 2;
10099 dgst_pos3 = 3;
10100 break;
10101
10102 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10103 salt_type = SALT_TYPE_EMBEDDED;
10104 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10105 opts_type = OPTS_TYPE_PT_GENERATE_LE
10106 | OPTS_TYPE_ST_BASE64
10107 | OPTS_TYPE_HASH_COPY;
10108 kern_type = KERN_TYPE_PBKDF2_SHA512;
10109 dgst_size = DGST_SIZE_8_16;
10110 parse_func = pbkdf2_sha512_parse_hash;
10111 sort_by_digest = sort_by_digest_8_16;
10112 opti_type = OPTI_TYPE_ZERO_BYTE
10113 | OPTI_TYPE_USES_BITS_64;
10114 dgst_pos0 = 0;
10115 dgst_pos1 = 1;
10116 dgst_pos2 = 2;
10117 dgst_pos3 = 3;
10118 break;
10119
10120 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10121 salt_type = SALT_TYPE_EMBEDDED;
10122 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10123 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10124 kern_type = KERN_TYPE_ECRYPTFS;
10125 dgst_size = DGST_SIZE_8_8;
10126 parse_func = ecryptfs_parse_hash;
10127 sort_by_digest = sort_by_digest_8_8;
10128 opti_type = OPTI_TYPE_ZERO_BYTE
10129 | OPTI_TYPE_USES_BITS_64;
10130 dgst_pos0 = 0;
10131 dgst_pos1 = 1;
10132 dgst_pos2 = 2;
10133 dgst_pos3 = 3;
10134 break;
10135
10136 case 12300: hash_type = HASH_TYPE_ORACLET;
10137 salt_type = SALT_TYPE_EMBEDDED;
10138 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10139 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10140 kern_type = KERN_TYPE_ORACLET;
10141 dgst_size = DGST_SIZE_8_16;
10142 parse_func = oraclet_parse_hash;
10143 sort_by_digest = sort_by_digest_8_16;
10144 opti_type = OPTI_TYPE_ZERO_BYTE
10145 | OPTI_TYPE_USES_BITS_64;
10146 dgst_pos0 = 0;
10147 dgst_pos1 = 1;
10148 dgst_pos2 = 2;
10149 dgst_pos3 = 3;
10150 break;
10151
10152 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10153 salt_type = SALT_TYPE_EMBEDDED;
10154 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10155 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10156 kern_type = KERN_TYPE_BSDICRYPT;
10157 dgst_size = DGST_SIZE_4_4;
10158 parse_func = bsdicrypt_parse_hash;
10159 sort_by_digest = sort_by_digest_4_4;
10160 opti_type = OPTI_TYPE_ZERO_BYTE
10161 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10162 dgst_pos0 = 0;
10163 dgst_pos1 = 1;
10164 dgst_pos2 = 2;
10165 dgst_pos3 = 3;
10166 break;
10167
10168 case 12500: hash_type = HASH_TYPE_RAR3HP;
10169 salt_type = SALT_TYPE_EMBEDDED;
10170 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10171 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10172 kern_type = KERN_TYPE_RAR3;
10173 dgst_size = DGST_SIZE_4_4;
10174 parse_func = rar3hp_parse_hash;
10175 sort_by_digest = sort_by_digest_4_4;
10176 opti_type = OPTI_TYPE_ZERO_BYTE;
10177 dgst_pos0 = 0;
10178 dgst_pos1 = 1;
10179 dgst_pos2 = 2;
10180 dgst_pos3 = 3;
10181 break;
10182
10183 case 12600: hash_type = HASH_TYPE_SHA256;
10184 salt_type = SALT_TYPE_INTERN;
10185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10186 opts_type = OPTS_TYPE_PT_GENERATE_BE
10187 | OPTS_TYPE_PT_ADD80;
10188 kern_type = KERN_TYPE_CF10;
10189 dgst_size = DGST_SIZE_4_8;
10190 parse_func = cf10_parse_hash;
10191 sort_by_digest = sort_by_digest_4_8;
10192 opti_type = OPTI_TYPE_ZERO_BYTE
10193 | OPTI_TYPE_PRECOMPUTE_INIT
10194 | OPTI_TYPE_EARLY_SKIP
10195 | OPTI_TYPE_NOT_ITERATED;
10196 dgst_pos0 = 3;
10197 dgst_pos1 = 7;
10198 dgst_pos2 = 2;
10199 dgst_pos3 = 6;
10200 break;
10201
10202 case 12700: hash_type = HASH_TYPE_AES;
10203 salt_type = SALT_TYPE_EMBEDDED;
10204 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10205 opts_type = OPTS_TYPE_PT_GENERATE_LE
10206 | OPTS_TYPE_HASH_COPY;
10207 kern_type = KERN_TYPE_MYWALLET;
10208 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10209 parse_func = mywallet_parse_hash;
10210 sort_by_digest = sort_by_digest_4_5;
10211 opti_type = OPTI_TYPE_ZERO_BYTE;
10212 dgst_pos0 = 0;
10213 dgst_pos1 = 1;
10214 dgst_pos2 = 2;
10215 dgst_pos3 = 3;
10216 break;
10217
10218 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10219 salt_type = SALT_TYPE_EMBEDDED;
10220 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10221 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10222 kern_type = KERN_TYPE_MS_DRSR;
10223 dgst_size = DGST_SIZE_4_8;
10224 parse_func = ms_drsr_parse_hash;
10225 sort_by_digest = sort_by_digest_4_8;
10226 opti_type = OPTI_TYPE_ZERO_BYTE;
10227 dgst_pos0 = 0;
10228 dgst_pos1 = 1;
10229 dgst_pos2 = 2;
10230 dgst_pos3 = 3;
10231 break;
10232
10233 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10234 salt_type = SALT_TYPE_EMBEDDED;
10235 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10236 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10237 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10238 dgst_size = DGST_SIZE_4_8;
10239 parse_func = androidfde_samsung_parse_hash;
10240 sort_by_digest = sort_by_digest_4_8;
10241 opti_type = OPTI_TYPE_ZERO_BYTE;
10242 dgst_pos0 = 0;
10243 dgst_pos1 = 1;
10244 dgst_pos2 = 2;
10245 dgst_pos3 = 3;
10246 break;
10247
10248 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10249 salt_type = SALT_TYPE_EMBEDDED;
10250 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10251 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10252 kern_type = KERN_TYPE_RAR5;
10253 dgst_size = DGST_SIZE_4_4;
10254 parse_func = rar5_parse_hash;
10255 sort_by_digest = sort_by_digest_4_4;
10256 opti_type = OPTI_TYPE_ZERO_BYTE;
10257 dgst_pos0 = 0;
10258 dgst_pos1 = 1;
10259 dgst_pos2 = 2;
10260 dgst_pos3 = 3;
10261 break;
10262
10263 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10264 salt_type = SALT_TYPE_EMBEDDED;
10265 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10266 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10267 kern_type = KERN_TYPE_KRB5TGS;
10268 dgst_size = DGST_SIZE_4_4;
10269 parse_func = krb5tgs_parse_hash;
10270 sort_by_digest = sort_by_digest_4_4;
10271 opti_type = OPTI_TYPE_ZERO_BYTE
10272 | OPTI_TYPE_NOT_ITERATED;
10273 dgst_pos0 = 0;
10274 dgst_pos1 = 1;
10275 dgst_pos2 = 2;
10276 dgst_pos3 = 3;
10277 break;
10278
10279 case 13200: hash_type = HASH_TYPE_AES;
10280 salt_type = SALT_TYPE_EMBEDDED;
10281 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10282 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10283 kern_type = KERN_TYPE_AXCRYPT;
10284 dgst_size = DGST_SIZE_4_4;
10285 parse_func = axcrypt_parse_hash;
10286 sort_by_digest = sort_by_digest_4_4;
10287 opti_type = OPTI_TYPE_ZERO_BYTE;
10288 dgst_pos0 = 0;
10289 dgst_pos1 = 1;
10290 dgst_pos2 = 2;
10291 dgst_pos3 = 3;
10292 break;
10293
10294 case 13300: hash_type = HASH_TYPE_SHA1;
10295 salt_type = SALT_TYPE_NONE;
10296 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10297 opts_type = OPTS_TYPE_PT_GENERATE_BE
10298 | OPTS_TYPE_PT_ADD80
10299 | OPTS_TYPE_PT_ADDBITS15;
10300 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10301 dgst_size = DGST_SIZE_4_5;
10302 parse_func = sha1axcrypt_parse_hash;
10303 sort_by_digest = sort_by_digest_4_5;
10304 opti_type = OPTI_TYPE_ZERO_BYTE
10305 | OPTI_TYPE_PRECOMPUTE_INIT
10306 | OPTI_TYPE_EARLY_SKIP
10307 | OPTI_TYPE_NOT_ITERATED
10308 | OPTI_TYPE_NOT_SALTED;
10309 dgst_pos0 = 0;
10310 dgst_pos1 = 4;
10311 dgst_pos2 = 3;
10312 dgst_pos3 = 2;
10313 break;
10314
10315 case 13400: hash_type = HASH_TYPE_AES;
10316 salt_type = SALT_TYPE_EMBEDDED;
10317 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10318 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10319 kern_type = KERN_TYPE_KEEPASS;
10320 dgst_size = DGST_SIZE_4_4;
10321 parse_func = keepass_parse_hash;
10322 sort_by_digest = sort_by_digest_4_4;
10323 opti_type = OPTI_TYPE_ZERO_BYTE;
10324 dgst_pos0 = 0;
10325 dgst_pos1 = 1;
10326 dgst_pos2 = 2;
10327 dgst_pos3 = 3;
10328 break;
10329
10330 case 13500: hash_type = HASH_TYPE_SHA1;
10331 salt_type = SALT_TYPE_EMBEDDED;
10332 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10333 opts_type = OPTS_TYPE_PT_GENERATE_BE
10334 | OPTS_TYPE_PT_UNICODE
10335 | OPTS_TYPE_PT_ADD80;
10336 kern_type = KERN_TYPE_PSTOKEN;
10337 dgst_size = DGST_SIZE_4_5;
10338 parse_func = pstoken_parse_hash;
10339 sort_by_digest = sort_by_digest_4_5;
10340 opti_type = OPTI_TYPE_ZERO_BYTE
10341 | OPTI_TYPE_PRECOMPUTE_INIT
10342 | OPTI_TYPE_EARLY_SKIP
10343 | OPTI_TYPE_NOT_ITERATED
10344 | OPTI_TYPE_PREPENDED_SALT
10345 | OPTI_TYPE_RAW_HASH;
10346 dgst_pos0 = 3;
10347 dgst_pos1 = 4;
10348 dgst_pos2 = 2;
10349 dgst_pos3 = 1;
10350 break;
10351
10352 default: usage_mini_print (PROGNAME); return (-1);
10353 }
10354
10355 /**
10356 * parser
10357 */
10358
10359 data.parse_func = parse_func;
10360
10361 /**
10362 * misc stuff
10363 */
10364
10365 if (hex_salt)
10366 {
10367 if (salt_type == SALT_TYPE_INTERN)
10368 {
10369 opts_type |= OPTS_TYPE_ST_HEX;
10370 }
10371 else
10372 {
10373 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10374
10375 return (-1);
10376 }
10377 }
10378
10379 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10380 | (salt_type == SALT_TYPE_EXTERN)
10381 | (salt_type == SALT_TYPE_EMBEDDED)
10382 | (salt_type == SALT_TYPE_VIRTUAL));
10383
10384 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10385
10386 data.hash_type = hash_type;
10387 data.attack_mode = attack_mode;
10388 data.attack_kern = attack_kern;
10389 data.attack_exec = attack_exec;
10390 data.kern_type = kern_type;
10391 data.opts_type = opts_type;
10392 data.dgst_size = dgst_size;
10393 data.salt_type = salt_type;
10394 data.isSalted = isSalted;
10395 data.sort_by_digest = sort_by_digest;
10396 data.dgst_pos0 = dgst_pos0;
10397 data.dgst_pos1 = dgst_pos1;
10398 data.dgst_pos2 = dgst_pos2;
10399 data.dgst_pos3 = dgst_pos3;
10400
10401 esalt_size = 0;
10402
10403 switch (hash_mode)
10404 {
10405 case 2500: esalt_size = sizeof (wpa_t); break;
10406 case 5300: esalt_size = sizeof (ikepsk_t); break;
10407 case 5400: esalt_size = sizeof (ikepsk_t); break;
10408 case 5500: esalt_size = sizeof (netntlm_t); break;
10409 case 5600: esalt_size = sizeof (netntlm_t); break;
10410 case 6211: esalt_size = sizeof (tc_t); break;
10411 case 6212: esalt_size = sizeof (tc_t); break;
10412 case 6213: esalt_size = sizeof (tc_t); break;
10413 case 6221: esalt_size = sizeof (tc_t); break;
10414 case 6222: esalt_size = sizeof (tc_t); break;
10415 case 6223: esalt_size = sizeof (tc_t); break;
10416 case 6231: esalt_size = sizeof (tc_t); break;
10417 case 6232: esalt_size = sizeof (tc_t); break;
10418 case 6233: esalt_size = sizeof (tc_t); break;
10419 case 6241: esalt_size = sizeof (tc_t); break;
10420 case 6242: esalt_size = sizeof (tc_t); break;
10421 case 6243: esalt_size = sizeof (tc_t); break;
10422 case 6600: esalt_size = sizeof (agilekey_t); break;
10423 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10424 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10425 case 7300: esalt_size = sizeof (rakp_t); break;
10426 case 7500: esalt_size = sizeof (krb5pa_t); break;
10427 case 8200: esalt_size = sizeof (cloudkey_t); break;
10428 case 8800: esalt_size = sizeof (androidfde_t); break;
10429 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10430 case 9400: esalt_size = sizeof (office2007_t); break;
10431 case 9500: esalt_size = sizeof (office2010_t); break;
10432 case 9600: esalt_size = sizeof (office2013_t); break;
10433 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10434 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10435 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10436 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10437 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10438 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10439 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10440 case 10200: esalt_size = sizeof (cram_md5_t); break;
10441 case 10400: esalt_size = sizeof (pdf_t); break;
10442 case 10410: esalt_size = sizeof (pdf_t); break;
10443 case 10420: esalt_size = sizeof (pdf_t); break;
10444 case 10500: esalt_size = sizeof (pdf_t); break;
10445 case 10600: esalt_size = sizeof (pdf_t); break;
10446 case 10700: esalt_size = sizeof (pdf_t); break;
10447 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10448 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10449 case 11400: esalt_size = sizeof (sip_t); break;
10450 case 11600: esalt_size = sizeof (seven_zip_t); break;
10451 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10452 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10453 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10454 case 13000: esalt_size = sizeof (rar5_t); break;
10455 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10456 case 13400: esalt_size = sizeof (keepass_t); break;
10457 case 13500: esalt_size = sizeof (pstoken_t); break;
10458 }
10459
10460 data.esalt_size = esalt_size;
10461
10462 /**
10463 * choose dictionary parser
10464 */
10465
10466 if (hash_type == HASH_TYPE_LM)
10467 {
10468 get_next_word_func = get_next_word_lm;
10469 }
10470 else if (opts_type & OPTS_TYPE_PT_UPPER)
10471 {
10472 get_next_word_func = get_next_word_uc;
10473 }
10474 else
10475 {
10476 get_next_word_func = get_next_word_std;
10477 }
10478
10479 /**
10480 * dictstat
10481 */
10482
10483 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10484
10485 #ifdef _POSIX
10486 size_t dictstat_nmemb = 0;
10487 #endif
10488
10489 #ifdef _WIN
10490 uint dictstat_nmemb = 0;
10491 #endif
10492
10493 char dictstat[256] = { 0 };
10494
10495 FILE *dictstat_fp = NULL;
10496
10497 if (keyspace == 0)
10498 {
10499 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10500
10501 dictstat_fp = fopen (dictstat, "rb");
10502
10503 if (dictstat_fp)
10504 {
10505 #ifdef _POSIX
10506 struct stat tmpstat;
10507
10508 fstat (fileno (dictstat_fp), &tmpstat);
10509 #endif
10510
10511 #ifdef _WIN
10512 struct stat64 tmpstat;
10513
10514 _fstat64 (fileno (dictstat_fp), &tmpstat);
10515 #endif
10516
10517 if (tmpstat.st_mtime < COMPTIME)
10518 {
10519 /* with v0.15 the format changed so we have to ensure user is using a good version
10520 since there is no version-header in the dictstat file */
10521
10522 fclose (dictstat_fp);
10523
10524 unlink (dictstat);
10525 }
10526 else
10527 {
10528 while (!feof (dictstat_fp))
10529 {
10530 dictstat_t d;
10531
10532 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10533
10534 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10535
10536 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10537 {
10538 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10539
10540 return -1;
10541 }
10542 }
10543
10544 fclose (dictstat_fp);
10545 }
10546 }
10547 }
10548
10549 /**
10550 * potfile
10551 */
10552
10553 char potfile[256] = { 0 };
10554
10555 if (potfile_path == NULL)
10556 {
10557 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10558 }
10559 else
10560 {
10561 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10562 }
10563
10564 data.pot_fp = NULL;
10565
10566 FILE *out_fp = NULL;
10567 FILE *pot_fp = NULL;
10568
10569 if (show == 1 || left == 1)
10570 {
10571 pot_fp = fopen (potfile, "rb");
10572
10573 if (pot_fp == NULL)
10574 {
10575 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10576
10577 return (-1);
10578 }
10579
10580 if (outfile != NULL)
10581 {
10582 if ((out_fp = fopen (outfile, "ab")) == NULL)
10583 {
10584 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10585
10586 fclose (pot_fp);
10587
10588 return (-1);
10589 }
10590 }
10591 else
10592 {
10593 out_fp = stdout;
10594 }
10595 }
10596 else
10597 {
10598 if (potfile_disable == 0)
10599 {
10600 pot_fp = fopen (potfile, "ab");
10601
10602 if (pot_fp == NULL)
10603 {
10604 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10605
10606 return (-1);
10607 }
10608
10609 data.pot_fp = pot_fp;
10610 }
10611 }
10612
10613 pot_t *pot = NULL;
10614
10615 uint pot_cnt = 0;
10616 uint pot_avail = 0;
10617
10618 if (show == 1 || left == 1)
10619 {
10620 SUPPRESS_OUTPUT = 1;
10621
10622 pot_avail = count_lines (pot_fp);
10623
10624 rewind (pot_fp);
10625
10626 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10627
10628 uint pot_hashes_avail = 0;
10629
10630 uint line_num = 0;
10631
10632 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10633
10634 while (!feof (pot_fp))
10635 {
10636 line_num++;
10637
10638 int line_len = fgetl (pot_fp, line_buf);
10639
10640 if (line_len == 0) continue;
10641
10642 char *plain_buf = line_buf + line_len;
10643
10644 pot_t *pot_ptr = &pot[pot_cnt];
10645
10646 hash_t *hashes_buf = &pot_ptr->hash;
10647
10648 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10649 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10650
10651 if (pot_cnt == pot_hashes_avail)
10652 {
10653 uint pos = 0;
10654
10655 for (pos = 0; pos < INCR_POT; pos++)
10656 {
10657 if ((pot_cnt + pos) >= pot_avail) break;
10658
10659 pot_t *tmp_pot = &pot[pot_cnt + pos];
10660
10661 hash_t *tmp_hash = &tmp_pot->hash;
10662
10663 tmp_hash->digest = mymalloc (dgst_size);
10664
10665 if (isSalted)
10666 {
10667 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10668 }
10669
10670 if (esalt_size)
10671 {
10672 tmp_hash->esalt = mymalloc (esalt_size);
10673 }
10674
10675 pot_hashes_avail++;
10676 }
10677 }
10678
10679 int plain_len = 0;
10680
10681 int parser_status;
10682
10683 int iter = MAX_CUT_TRIES;
10684
10685 do
10686 {
10687 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10688 {
10689 if (line_buf[i] == ':')
10690 {
10691 line_len--;
10692
10693 break;
10694 }
10695 }
10696
10697 if (data.hash_mode != 2500)
10698 {
10699 parser_status = parse_func (line_buf, line_len, hashes_buf);
10700 }
10701 else
10702 {
10703 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10704
10705 if (line_len > max_salt_size)
10706 {
10707 parser_status = PARSER_GLOBAL_LENGTH;
10708 }
10709 else
10710 {
10711 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10712
10713 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10714
10715 hashes_buf->salt->salt_len = line_len;
10716
10717 parser_status = PARSER_OK;
10718 }
10719 }
10720
10721 // if NOT parsed without error, we add the ":" to the plain
10722
10723 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10724 {
10725 plain_len++;
10726 plain_buf--;
10727 }
10728
10729 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10730
10731 if (parser_status < PARSER_GLOBAL_ZERO)
10732 {
10733 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10734
10735 continue;
10736 }
10737
10738 if (plain_len >= 255) continue;
10739
10740 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10741
10742 pot_ptr->plain_len = plain_len;
10743
10744 pot_cnt++;
10745 }
10746
10747 myfree (line_buf);
10748
10749 fclose (pot_fp);
10750
10751 SUPPRESS_OUTPUT = 0;
10752
10753 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10754 }
10755
10756 /**
10757 * word len
10758 */
10759
10760 uint pw_min = PW_MIN;
10761 uint pw_max = PW_MAX;
10762
10763 switch (hash_mode)
10764 {
10765 case 125: if (pw_max > 32) pw_max = 32;
10766 break;
10767 case 400: if (pw_max > 40) pw_max = 40;
10768 break;
10769 case 500: if (pw_max > 16) pw_max = 16;
10770 break;
10771 case 1500: if (pw_max > 8) pw_max = 8;
10772 break;
10773 case 1600: if (pw_max > 16) pw_max = 16;
10774 break;
10775 case 1800: if (pw_max > 16) pw_max = 16;
10776 break;
10777 case 2100: if (pw_max > 16) pw_max = 16;
10778 break;
10779 case 2500: if (pw_min < 8) pw_min = 8;
10780 break;
10781 case 3000: if (pw_max > 7) pw_max = 7;
10782 break;
10783 case 5200: if (pw_max > 24) pw_max = 24;
10784 break;
10785 case 5800: if (pw_max > 16) pw_max = 16;
10786 break;
10787 case 6300: if (pw_max > 16) pw_max = 16;
10788 break;
10789 case 7400: if (pw_max > 16) pw_max = 16;
10790 break;
10791 case 7900: if (pw_max > 48) pw_max = 48;
10792 break;
10793 case 8500: if (pw_max > 8) pw_max = 8;
10794 break;
10795 case 8600: if (pw_max > 16) pw_max = 16;
10796 break;
10797 case 9710: pw_min = 5;
10798 pw_max = 5;
10799 break;
10800 case 9810: pw_min = 5;
10801 pw_max = 5;
10802 break;
10803 case 10410: pw_min = 5;
10804 pw_max = 5;
10805 break;
10806 case 10300: if (pw_max < 3) pw_min = 3;
10807 if (pw_max > 40) pw_max = 40;
10808 break;
10809 case 10500: if (pw_max < 3) pw_min = 3;
10810 if (pw_max > 40) pw_max = 40;
10811 break;
10812 case 10700: if (pw_max > 16) pw_max = 16;
10813 break;
10814 case 11300: if (pw_max > 40) pw_max = 40;
10815 break;
10816 case 12500: if (pw_max > 20) pw_max = 20;
10817 break;
10818 case 12800: if (pw_max > 24) pw_max = 24;
10819 break;
10820 }
10821
10822 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10823 {
10824 switch (attack_kern)
10825 {
10826 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10827 break;
10828 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10829 break;
10830 }
10831 }
10832
10833 /**
10834 * charsets : keep them together for more easy maintainnce
10835 */
10836
10837 cs_t mp_sys[6] = { { { 0 }, 0 } };
10838 cs_t mp_usr[4] = { { { 0 }, 0 } };
10839
10840 mp_setup_sys (mp_sys);
10841
10842 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10843 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10844 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10845 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10846
10847 /**
10848 * load hashes, part I: find input mode, count hashes
10849 */
10850
10851 uint hashlist_mode = 0;
10852 uint hashlist_format = HLFMT_HASHCAT;
10853
10854 uint hashes_avail = 0;
10855
10856 if (benchmark == 0)
10857 {
10858 struct stat f;
10859
10860 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10861
10862 if ((hash_mode == 2500) ||
10863 (hash_mode == 5200) ||
10864 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10865 (hash_mode == 9000))
10866 {
10867 hashlist_mode = HL_MODE_ARG;
10868
10869 char *hashfile = myargv[optind];
10870
10871 data.hashfile = hashfile;
10872
10873 logfile_top_var_string ("target", hashfile);
10874 }
10875
10876 if (hashlist_mode == HL_MODE_ARG)
10877 {
10878 if (hash_mode == 2500)
10879 {
10880 struct stat st;
10881
10882 if (stat (data.hashfile, &st) == -1)
10883 {
10884 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10885
10886 return (-1);
10887 }
10888
10889 hashes_avail = st.st_size / sizeof (hccap_t);
10890 }
10891 else
10892 {
10893 hashes_avail = 1;
10894 }
10895 }
10896 else if (hashlist_mode == HL_MODE_FILE)
10897 {
10898 char *hashfile = myargv[optind];
10899
10900 data.hashfile = hashfile;
10901
10902 logfile_top_var_string ("target", hashfile);
10903
10904 FILE *fp = NULL;
10905
10906 if ((fp = fopen (hashfile, "rb")) == NULL)
10907 {
10908 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10909
10910 return (-1);
10911 }
10912
10913 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10914
10915 hashes_avail = count_lines (fp);
10916
10917 rewind (fp);
10918
10919 if (hashes_avail == 0)
10920 {
10921 log_error ("ERROR: hashfile is empty or corrupt");
10922
10923 fclose (fp);
10924
10925 return (-1);
10926 }
10927
10928 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10929
10930 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10931 {
10932 log_error ("ERROR: remove not supported in native hashfile-format mode");
10933
10934 fclose (fp);
10935
10936 return (-1);
10937 }
10938
10939 fclose (fp);
10940 }
10941 }
10942 else
10943 {
10944 hashlist_mode = HL_MODE_ARG;
10945
10946 hashes_avail = 1;
10947 }
10948
10949 if (hash_mode == 3000) hashes_avail *= 2;
10950
10951 data.hashlist_mode = hashlist_mode;
10952 data.hashlist_format = hashlist_format;
10953
10954 logfile_top_uint (hashlist_mode);
10955 logfile_top_uint (hashlist_format);
10956
10957 /**
10958 * load hashes, part II: allocate required memory, set pointers
10959 */
10960
10961 hash_t *hashes_buf = NULL;
10962 void *digests_buf = NULL;
10963 salt_t *salts_buf = NULL;
10964 void *esalts_buf = NULL;
10965
10966 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10967
10968 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10969
10970 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10971 {
10972 u32 hash_pos;
10973
10974 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10975 {
10976 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10977
10978 hashes_buf[hash_pos].hash_info = hash_info;
10979
10980 if (username && (remove || show || left))
10981 {
10982 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10983 }
10984
10985 if (benchmark)
10986 {
10987 hash_info->orighash = (char *) mymalloc (256);
10988 }
10989 }
10990 }
10991
10992 if (isSalted)
10993 {
10994 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10995
10996 if (esalt_size)
10997 {
10998 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10999 }
11000 }
11001 else
11002 {
11003 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11004 }
11005
11006 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11007 {
11008 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11009
11010 if (isSalted)
11011 {
11012 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11013
11014 if (esalt_size)
11015 {
11016 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11017 }
11018 }
11019 else
11020 {
11021 hashes_buf[hash_pos].salt = &salts_buf[0];
11022 }
11023 }
11024
11025 /**
11026 * load hashes, part III: parse hashes or generate them if benchmark
11027 */
11028
11029 uint hashes_cnt = 0;
11030
11031 if (benchmark == 0)
11032 {
11033 if (keyspace == 1)
11034 {
11035 // useless to read hash file for keyspace, cheat a little bit w/ optind
11036 }
11037 else if (hashes_avail == 0)
11038 {
11039 }
11040 else if (hashlist_mode == HL_MODE_ARG)
11041 {
11042 char *input_buf = myargv[optind];
11043
11044 uint input_len = strlen (input_buf);
11045
11046 logfile_top_var_string ("target", input_buf);
11047
11048 char *hash_buf = NULL;
11049 int hash_len = 0;
11050
11051 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11052
11053 bool hash_fmt_error = 0;
11054
11055 if (hash_len < 1) hash_fmt_error = 1;
11056 if (hash_buf == NULL) hash_fmt_error = 1;
11057
11058 if (hash_fmt_error)
11059 {
11060 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11061 }
11062 else
11063 {
11064 if (opts_type & OPTS_TYPE_HASH_COPY)
11065 {
11066 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11067
11068 hash_info_tmp->orighash = mystrdup (hash_buf);
11069 }
11070
11071 if (isSalted)
11072 {
11073 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11074 }
11075
11076 int parser_status = PARSER_OK;
11077
11078 if (hash_mode == 2500)
11079 {
11080 if (hash_len == 0)
11081 {
11082 log_error ("ERROR: hccap file not specified");
11083
11084 return (-1);
11085 }
11086
11087 hashlist_mode = HL_MODE_FILE;
11088
11089 data.hashlist_mode = hashlist_mode;
11090
11091 FILE *fp = fopen (hash_buf, "rb");
11092
11093 if (fp == NULL)
11094 {
11095 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11096
11097 return (-1);
11098 }
11099
11100 if (hashes_avail < 1)
11101 {
11102 log_error ("ERROR: hccap file is empty or corrupt");
11103
11104 fclose (fp);
11105
11106 return (-1);
11107 }
11108
11109 uint hccap_size = sizeof (hccap_t);
11110
11111 char *in = (char *) mymalloc (hccap_size);
11112
11113 while (!feof (fp))
11114 {
11115 int n = fread (in, hccap_size, 1, fp);
11116
11117 if (n != 1)
11118 {
11119 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11120
11121 break;
11122 }
11123
11124 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11125
11126 if (parser_status != PARSER_OK)
11127 {
11128 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11129
11130 continue;
11131 }
11132
11133 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11134
11135 if ((show == 1) || (left == 1))
11136 {
11137 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11138
11139 char *salt_ptr = (char *) tmp_salt->salt_buf;
11140
11141 int cur_pos = tmp_salt->salt_len;
11142 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11143
11144 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11145
11146 // do the appending task
11147
11148 snprintf (salt_ptr + cur_pos,
11149 rem_len,
11150 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11151 wpa->orig_mac1[0],
11152 wpa->orig_mac1[1],
11153 wpa->orig_mac1[2],
11154 wpa->orig_mac1[3],
11155 wpa->orig_mac1[4],
11156 wpa->orig_mac1[5],
11157 wpa->orig_mac2[0],
11158 wpa->orig_mac2[1],
11159 wpa->orig_mac2[2],
11160 wpa->orig_mac2[3],
11161 wpa->orig_mac2[4],
11162 wpa->orig_mac2[5]);
11163
11164 // memset () the remaining part of the salt
11165
11166 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11167 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11168
11169 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11170
11171 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11172 }
11173
11174 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);
11175 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);
11176
11177 hashes_cnt++;
11178 }
11179
11180 fclose (fp);
11181
11182 myfree (in);
11183 }
11184 else if (hash_mode == 3000)
11185 {
11186 if (hash_len == 32)
11187 {
11188 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11189
11190 hash_t *lm_hash_left = NULL;
11191
11192 if (parser_status == PARSER_OK)
11193 {
11194 lm_hash_left = &hashes_buf[hashes_cnt];
11195
11196 hashes_cnt++;
11197 }
11198 else
11199 {
11200 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11201 }
11202
11203 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11204
11205 hash_t *lm_hash_right = NULL;
11206
11207 if (parser_status == PARSER_OK)
11208 {
11209 lm_hash_right = &hashes_buf[hashes_cnt];
11210
11211 hashes_cnt++;
11212 }
11213 else
11214 {
11215 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11216 }
11217
11218 // show / left
11219
11220 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11221 {
11222 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);
11223 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);
11224 }
11225 }
11226 else
11227 {
11228 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11229
11230 if (parser_status == PARSER_OK)
11231 {
11232 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11233 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11234 }
11235
11236 if (parser_status == PARSER_OK)
11237 {
11238 hashes_cnt++;
11239 }
11240 else
11241 {
11242 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11243 }
11244 }
11245 }
11246 else
11247 {
11248 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11249
11250 if (parser_status == PARSER_OK)
11251 {
11252 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11253 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11254 }
11255
11256 if (parser_status == PARSER_OK)
11257 {
11258 hashes_cnt++;
11259 }
11260 else
11261 {
11262 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11263 }
11264 }
11265 }
11266 }
11267 else if (hashlist_mode == HL_MODE_FILE)
11268 {
11269 char *hashfile = data.hashfile;
11270
11271 FILE *fp;
11272
11273 if ((fp = fopen (hashfile, "rb")) == NULL)
11274 {
11275 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11276
11277 return (-1);
11278 }
11279
11280 uint line_num = 0;
11281
11282 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11283
11284 while (!feof (fp))
11285 {
11286 line_num++;
11287
11288 int line_len = fgetl (fp, line_buf);
11289
11290 if (line_len == 0) continue;
11291
11292 char *hash_buf = NULL;
11293 int hash_len = 0;
11294
11295 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11296
11297 bool hash_fmt_error = 0;
11298
11299 if (hash_len < 1) hash_fmt_error = 1;
11300 if (hash_buf == NULL) hash_fmt_error = 1;
11301
11302 if (hash_fmt_error)
11303 {
11304 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11305
11306 continue;
11307 }
11308
11309 if (username)
11310 {
11311 char *user_buf = NULL;
11312 int user_len = 0;
11313
11314 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11315
11316 if (remove || show)
11317 {
11318 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11319
11320 *user = (user_t *) mymalloc (sizeof (user_t));
11321
11322 user_t *user_ptr = *user;
11323
11324 if (user_buf != NULL)
11325 {
11326 user_ptr->user_name = mystrdup (user_buf);
11327 }
11328 else
11329 {
11330 user_ptr->user_name = mystrdup ("");
11331 }
11332
11333 user_ptr->user_len = user_len;
11334 }
11335 }
11336
11337 if (opts_type & OPTS_TYPE_HASH_COPY)
11338 {
11339 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11340
11341 hash_info_tmp->orighash = mystrdup (hash_buf);
11342 }
11343
11344 if (isSalted)
11345 {
11346 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11347 }
11348
11349 if (hash_mode == 3000)
11350 {
11351 if (hash_len == 32)
11352 {
11353 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11354
11355 if (parser_status < PARSER_GLOBAL_ZERO)
11356 {
11357 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11358
11359 continue;
11360 }
11361
11362 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11363
11364 hashes_cnt++;
11365
11366 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11367
11368 if (parser_status < PARSER_GLOBAL_ZERO)
11369 {
11370 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11371
11372 continue;
11373 }
11374
11375 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11376
11377 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);
11378
11379 hashes_cnt++;
11380
11381 // show / left
11382
11383 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);
11384 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);
11385 }
11386 else
11387 {
11388 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11389
11390 if (parser_status < PARSER_GLOBAL_ZERO)
11391 {
11392 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11393
11394 continue;
11395 }
11396
11397 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);
11398
11399 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11400 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11401
11402 hashes_cnt++;
11403 }
11404 }
11405 else
11406 {
11407 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11408
11409 if (parser_status < PARSER_GLOBAL_ZERO)
11410 {
11411 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11412
11413 continue;
11414 }
11415
11416 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);
11417
11418 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11419 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11420
11421 hashes_cnt++;
11422 }
11423 }
11424
11425 myfree (line_buf);
11426
11427 fclose (fp);
11428
11429 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11430
11431 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11432 }
11433 }
11434 else
11435 {
11436 if (isSalted)
11437 {
11438 hashes_buf[0].salt->salt_len = 8;
11439
11440 // special salt handling
11441
11442 switch (hash_mode)
11443 {
11444 case 1500: hashes_buf[0].salt->salt_len = 2;
11445 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11446 break;
11447 case 1731: hashes_buf[0].salt->salt_len = 4;
11448 break;
11449 case 2410: hashes_buf[0].salt->salt_len = 4;
11450 break;
11451 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11452 break;
11453 case 3100: hashes_buf[0].salt->salt_len = 1;
11454 break;
11455 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11456 break;
11457 case 5800: hashes_buf[0].salt->salt_len = 16;
11458 break;
11459 case 6800: hashes_buf[0].salt->salt_len = 32;
11460 break;
11461 case 8400: hashes_buf[0].salt->salt_len = 40;
11462 break;
11463 case 8800: hashes_buf[0].salt->salt_len = 16;
11464 break;
11465 case 8900: hashes_buf[0].salt->salt_len = 16;
11466 hashes_buf[0].salt->scrypt_N = 1024;
11467 hashes_buf[0].salt->scrypt_r = 1;
11468 hashes_buf[0].salt->scrypt_p = 1;
11469 break;
11470 case 9100: hashes_buf[0].salt->salt_len = 16;
11471 break;
11472 case 9300: hashes_buf[0].salt->salt_len = 14;
11473 hashes_buf[0].salt->scrypt_N = 16384;
11474 hashes_buf[0].salt->scrypt_r = 1;
11475 hashes_buf[0].salt->scrypt_p = 1;
11476 break;
11477 case 9400: hashes_buf[0].salt->salt_len = 16;
11478 break;
11479 case 9500: hashes_buf[0].salt->salt_len = 16;
11480 break;
11481 case 9600: hashes_buf[0].salt->salt_len = 16;
11482 break;
11483 case 9700: hashes_buf[0].salt->salt_len = 16;
11484 break;
11485 case 9710: hashes_buf[0].salt->salt_len = 16;
11486 break;
11487 case 9720: hashes_buf[0].salt->salt_len = 16;
11488 break;
11489 case 9800: hashes_buf[0].salt->salt_len = 16;
11490 break;
11491 case 9810: hashes_buf[0].salt->salt_len = 16;
11492 break;
11493 case 9820: hashes_buf[0].salt->salt_len = 16;
11494 break;
11495 case 10300: hashes_buf[0].salt->salt_len = 12;
11496 break;
11497 case 11500: hashes_buf[0].salt->salt_len = 4;
11498 break;
11499 case 11600: hashes_buf[0].salt->salt_len = 4;
11500 break;
11501 case 12400: hashes_buf[0].salt->salt_len = 4;
11502 break;
11503 case 12500: hashes_buf[0].salt->salt_len = 8;
11504 break;
11505 case 12600: hashes_buf[0].salt->salt_len = 64;
11506 break;
11507 }
11508
11509 // special esalt handling
11510
11511 switch (hash_mode)
11512 {
11513 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11514 break;
11515 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11516 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11517 break;
11518 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11519 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11520 break;
11521 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11522 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11523 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11524 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11525 break;
11526 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11527 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11528 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11529 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11530 break;
11531 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11532 break;
11533 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11534 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11535 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11536 break;
11537 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11538 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11539 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11540 break;
11541 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11542 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11543 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11544 break;
11545 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11546 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11547 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11548 break;
11549 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11550 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11551 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11552 break;
11553 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11554 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11555 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11556 break;
11557 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11558 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11559 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11560 break;
11561 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11562 break;
11563 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11564 break;
11565 }
11566 }
11567
11568 // set hashfile
11569
11570 switch (hash_mode)
11571 {
11572 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11573 break;
11574 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11575 break;
11576 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11577 break;
11578 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11579 break;
11580 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11581 break;
11582 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11583 break;
11584 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11585 break;
11586 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11587 break;
11588 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11589 break;
11590 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11591 break;
11592 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11593 break;
11594 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11595 break;
11596 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11597 break;
11598 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11599 break;
11600 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11601 break;
11602 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11603 break;
11604 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11605 break;
11606 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11607 break;
11608 }
11609
11610 // set default iterations
11611
11612 switch (hash_mode)
11613 {
11614 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11615 break;
11616 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11617 break;
11618 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11619 break;
11620 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11621 break;
11622 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11623 break;
11624 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11625 break;
11626 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11627 break;
11628 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11629 break;
11630 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11631 break;
11632 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11633 break;
11634 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11635 break;
11636 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11637 break;
11638 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11639 break;
11640 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11641 break;
11642 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11643 break;
11644 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11645 break;
11646 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11647 break;
11648 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11649 break;
11650 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11651 break;
11652 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11653 break;
11654 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11655 break;
11656 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11657 break;
11658 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11659 break;
11660 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11661 break;
11662 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11663 break;
11664 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11665 break;
11666 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11667 break;
11668 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11669 break;
11670 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11671 break;
11672 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11673 break;
11674 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11675 break;
11676 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11677 break;
11678 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11679 break;
11680 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11681 break;
11682 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11683 break;
11684 case 8900: hashes_buf[0].salt->salt_iter = 1;
11685 break;
11686 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11687 break;
11688 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11689 break;
11690 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11691 break;
11692 case 9300: hashes_buf[0].salt->salt_iter = 1;
11693 break;
11694 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11695 break;
11696 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11697 break;
11698 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11699 break;
11700 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11701 break;
11702 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11703 break;
11704 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11705 break;
11706 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11707 break;
11708 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11709 break;
11710 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11711 break;
11712 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11713 break;
11714 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11715 break;
11716 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11717 break;
11718 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11719 break;
11720 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11721 break;
11722 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11723 break;
11724 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11725 break;
11726 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11727 break;
11728 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11729 break;
11730 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11731 break;
11732 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11733 break;
11734 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11735 break;
11736 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11737 break;
11738 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11739 break;
11740 }
11741
11742 hashes_cnt = 1;
11743 }
11744
11745 if (show == 1 || left == 1)
11746 {
11747 for (uint i = 0; i < pot_cnt; i++)
11748 {
11749 pot_t *pot_ptr = &pot[i];
11750
11751 hash_t *hashes_buf = &pot_ptr->hash;
11752
11753 local_free (hashes_buf->digest);
11754
11755 if (isSalted)
11756 {
11757 local_free (hashes_buf->salt);
11758 }
11759 }
11760
11761 local_free (pot);
11762
11763 if (data.quiet == 0) log_info_nn ("");
11764
11765 return (0);
11766 }
11767
11768 if (keyspace == 0)
11769 {
11770 if (hashes_cnt == 0)
11771 {
11772 log_error ("ERROR: No hashes loaded");
11773
11774 return (-1);
11775 }
11776 }
11777
11778 /**
11779 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11780 */
11781
11782 if (data.outfile != NULL)
11783 {
11784 if (data.hashfile != NULL)
11785 {
11786 #ifdef _POSIX
11787 struct stat tmpstat_outfile;
11788 struct stat tmpstat_hashfile;
11789 #endif
11790
11791 #ifdef _WIN
11792 struct stat64 tmpstat_outfile;
11793 struct stat64 tmpstat_hashfile;
11794 #endif
11795
11796 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11797
11798 if (tmp_outfile_fp)
11799 {
11800 #ifdef _POSIX
11801 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11802 #endif
11803
11804 #ifdef _WIN
11805 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11806 #endif
11807
11808 fclose (tmp_outfile_fp);
11809 }
11810
11811 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11812
11813 if (tmp_hashfile_fp)
11814 {
11815 #ifdef _POSIX
11816 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11817 #endif
11818
11819 #ifdef _WIN
11820 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11821 #endif
11822
11823 fclose (tmp_hashfile_fp);
11824 }
11825
11826 if (tmp_outfile_fp && tmp_outfile_fp)
11827 {
11828 tmpstat_outfile.st_mode = 0;
11829 tmpstat_outfile.st_nlink = 0;
11830 tmpstat_outfile.st_uid = 0;
11831 tmpstat_outfile.st_gid = 0;
11832 tmpstat_outfile.st_rdev = 0;
11833 tmpstat_outfile.st_atime = 0;
11834
11835 tmpstat_hashfile.st_mode = 0;
11836 tmpstat_hashfile.st_nlink = 0;
11837 tmpstat_hashfile.st_uid = 0;
11838 tmpstat_hashfile.st_gid = 0;
11839 tmpstat_hashfile.st_rdev = 0;
11840 tmpstat_hashfile.st_atime = 0;
11841
11842 #ifdef _POSIX
11843 tmpstat_outfile.st_blksize = 0;
11844 tmpstat_outfile.st_blocks = 0;
11845
11846 tmpstat_hashfile.st_blksize = 0;
11847 tmpstat_hashfile.st_blocks = 0;
11848 #endif
11849
11850 #ifdef _POSIX
11851 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11852 {
11853 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11854
11855 return (-1);
11856 }
11857 #endif
11858
11859 #ifdef _WIN
11860 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11861 {
11862 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11863
11864 return (-1);
11865 }
11866 #endif
11867 }
11868 }
11869 }
11870
11871 /**
11872 * Remove duplicates
11873 */
11874
11875 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11876
11877 if (isSalted)
11878 {
11879 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11880 }
11881 else
11882 {
11883 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11884 }
11885
11886 uint hashes_cnt_orig = hashes_cnt;
11887
11888 hashes_cnt = 1;
11889
11890 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11891 {
11892 if (isSalted)
11893 {
11894 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11895 {
11896 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11897 }
11898 }
11899 else
11900 {
11901 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11902 }
11903
11904 if (hashes_pos > hashes_cnt)
11905 {
11906 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11907 }
11908
11909 hashes_cnt++;
11910 }
11911
11912 /**
11913 * Potfile removes
11914 */
11915
11916 uint potfile_remove_cracks = 0;
11917
11918 if (potfile_disable == 0)
11919 {
11920 hash_t hash_buf;
11921
11922 hash_buf.digest = mymalloc (dgst_size);
11923 hash_buf.salt = NULL;
11924 hash_buf.esalt = NULL;
11925 hash_buf.hash_info = NULL;
11926 hash_buf.cracked = 0;
11927
11928 if (isSalted)
11929 {
11930 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11931 }
11932
11933 if (esalt_size)
11934 {
11935 hash_buf.esalt = mymalloc (esalt_size);
11936 }
11937
11938 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11939
11940 // no solution for these special hash types (for instane because they use hashfile in output etc)
11941 if ((hash_mode != 5200) &&
11942 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11943 (hash_mode != 9000))
11944 {
11945 FILE *fp = fopen (potfile, "rb");
11946
11947 if (fp != NULL)
11948 {
11949 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11950
11951 // to be safe work with a copy (because of line_len loop, i etc)
11952 // moved up here because it's easier to handle continue case
11953 // it's just 64kb
11954
11955 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11956
11957 while (!feof (fp))
11958 {
11959 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11960
11961 if (ptr == NULL) break;
11962
11963 int line_len = strlen (line_buf);
11964
11965 if (line_len == 0) continue;
11966
11967 int iter = MAX_CUT_TRIES;
11968
11969 for (int i = line_len - 1; i && iter; i--, line_len--)
11970 {
11971 if (line_buf[i] != ':') continue;
11972
11973 if (isSalted)
11974 {
11975 memset (hash_buf.salt, 0, sizeof (salt_t));
11976 }
11977
11978 hash_t *found = NULL;
11979
11980 if (hash_mode == 6800)
11981 {
11982 if (i < 64) // 64 = 16 * uint in salt_buf[]
11983 {
11984 // manipulate salt_buf
11985 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11986
11987 hash_buf.salt->salt_len = i;
11988
11989 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11990 }
11991 }
11992 else if (hash_mode == 2500)
11993 {
11994 if (i < 64) // 64 = 16 * uint in salt_buf[]
11995 {
11996 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11997 // manipulate salt_buf
11998
11999 memcpy (line_buf_cpy, line_buf, i);
12000
12001 char *mac2_pos = strrchr (line_buf_cpy, ':');
12002
12003 if (mac2_pos == NULL) continue;
12004
12005 mac2_pos[0] = 0;
12006 mac2_pos++;
12007
12008 if (strlen (mac2_pos) != 12) continue;
12009
12010 char *mac1_pos = strrchr (line_buf_cpy, ':');
12011
12012 if (mac1_pos == NULL) continue;
12013
12014 mac1_pos[0] = 0;
12015 mac1_pos++;
12016
12017 if (strlen (mac1_pos) != 12) continue;
12018
12019 uint essid_length = mac1_pos - line_buf_cpy - 1;
12020
12021 // here we need the ESSID
12022 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12023
12024 hash_buf.salt->salt_len = essid_length;
12025
12026 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12027
12028 if (found)
12029 {
12030 wpa_t *wpa = (wpa_t *) found->esalt;
12031
12032 // compare hex string(s) vs binary MAC address(es)
12033
12034 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12035 {
12036 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12037 {
12038 found = NULL;
12039
12040 break;
12041 }
12042 }
12043
12044 // early skip ;)
12045 if (!found) continue;
12046
12047 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12048 {
12049 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12050 {
12051 found = NULL;
12052
12053 break;
12054 }
12055 }
12056 }
12057 }
12058 }
12059 else
12060 {
12061 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12062
12063 if (parser_status == PARSER_OK)
12064 {
12065 if (isSalted)
12066 {
12067 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12068 }
12069 else
12070 {
12071 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12072 }
12073 }
12074 }
12075
12076 if (found == NULL) continue;
12077
12078 if (!found->cracked) potfile_remove_cracks++;
12079
12080 found->cracked = 1;
12081
12082 if (found) break;
12083
12084 iter--;
12085 }
12086 }
12087
12088 myfree (line_buf_cpy);
12089
12090 myfree (line_buf);
12091
12092 fclose (fp);
12093 }
12094 }
12095
12096 if (esalt_size)
12097 {
12098 local_free (hash_buf.esalt);
12099 }
12100
12101 if (isSalted)
12102 {
12103 local_free (hash_buf.salt);
12104 }
12105
12106 local_free (hash_buf.digest);
12107 }
12108
12109 /**
12110 * Now generate all the buffers required for later
12111 */
12112
12113 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12114
12115 salt_t *salts_buf_new = NULL;
12116 void *esalts_buf_new = NULL;
12117
12118 if (isSalted)
12119 {
12120 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12121
12122 if (esalt_size)
12123 {
12124 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12125 }
12126 }
12127 else
12128 {
12129 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12130 }
12131
12132 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12133
12134 uint digests_cnt = hashes_cnt;
12135 uint digests_done = 0;
12136
12137 uint size_digests = digests_cnt * dgst_size;
12138 uint size_shown = digests_cnt * sizeof (uint);
12139
12140 uint *digests_shown = (uint *) mymalloc (size_shown);
12141 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12142
12143 uint salts_cnt = 0;
12144 uint salts_done = 0;
12145
12146 hashinfo_t **hash_info = NULL;
12147
12148 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12149 {
12150 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12151
12152 if (username && (remove || show))
12153 {
12154 uint user_pos;
12155
12156 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12157 {
12158 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12159
12160 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12161 }
12162 }
12163 }
12164
12165 uint *salts_shown = (uint *) mymalloc (size_shown);
12166
12167 salt_t *salt_buf;
12168
12169 {
12170 // copied from inner loop
12171
12172 salt_buf = &salts_buf_new[salts_cnt];
12173
12174 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12175
12176 if (esalt_size)
12177 {
12178 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12179 }
12180
12181 salt_buf->digests_cnt = 0;
12182 salt_buf->digests_done = 0;
12183 salt_buf->digests_offset = 0;
12184
12185 salts_cnt++;
12186 }
12187
12188 if (hashes_buf[0].cracked == 1)
12189 {
12190 digests_shown[0] = 1;
12191
12192 digests_done++;
12193
12194 salt_buf->digests_done++;
12195 }
12196
12197 salt_buf->digests_cnt++;
12198
12199 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12200
12201 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12202 {
12203 hash_info[0] = hashes_buf[0].hash_info;
12204 }
12205
12206 // copy from inner loop
12207
12208 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12209 {
12210 if (isSalted)
12211 {
12212 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12213 {
12214 salt_buf = &salts_buf_new[salts_cnt];
12215
12216 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12217
12218 if (esalt_size)
12219 {
12220 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12221 }
12222
12223 salt_buf->digests_cnt = 0;
12224 salt_buf->digests_done = 0;
12225 salt_buf->digests_offset = hashes_pos;
12226
12227 salts_cnt++;
12228 }
12229 }
12230
12231 if (hashes_buf[hashes_pos].cracked == 1)
12232 {
12233 digests_shown[hashes_pos] = 1;
12234
12235 digests_done++;
12236
12237 salt_buf->digests_done++;
12238 }
12239
12240 salt_buf->digests_cnt++;
12241
12242 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12243
12244 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12245 {
12246 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12247 }
12248 }
12249
12250 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12251 {
12252 salt_t *salt_buf = &salts_buf_new[salt_pos];
12253
12254 if (salt_buf->digests_done == salt_buf->digests_cnt)
12255 {
12256 salts_shown[salt_pos] = 1;
12257
12258 salts_done++;
12259 }
12260
12261 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12262 }
12263
12264 local_free (digests_buf);
12265 local_free (salts_buf);
12266 local_free (esalts_buf);
12267
12268 digests_buf = digests_buf_new;
12269 salts_buf = salts_buf_new;
12270 esalts_buf = esalts_buf_new;
12271
12272 local_free (hashes_buf);
12273
12274 /**
12275 * special modification not set from parser
12276 */
12277
12278 switch (hash_mode)
12279 {
12280 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12281 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12282 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12283 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12284 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12285 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12286 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12287 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12288 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12289 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12290 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12291 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12292 }
12293
12294 if (truecrypt_keyfiles)
12295 {
12296 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12297
12298 char *keyfiles = strdup (truecrypt_keyfiles);
12299
12300 char *keyfile = strtok (keyfiles, ",");
12301
12302 do
12303 {
12304 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12305
12306 } while ((keyfile = strtok (NULL, ",")) != NULL);
12307
12308 free (keyfiles);
12309 }
12310
12311 data.digests_cnt = digests_cnt;
12312 data.digests_done = digests_done;
12313 data.digests_buf = digests_buf;
12314 data.digests_shown = digests_shown;
12315 data.digests_shown_tmp = digests_shown_tmp;
12316
12317 data.salts_cnt = salts_cnt;
12318 data.salts_done = salts_done;
12319 data.salts_buf = salts_buf;
12320 data.salts_shown = salts_shown;
12321
12322 data.esalts_buf = esalts_buf;
12323 data.hash_info = hash_info;
12324
12325 /**
12326 * Automatic Optimizers
12327 */
12328
12329 if (salts_cnt == 1)
12330 opti_type |= OPTI_TYPE_SINGLE_SALT;
12331
12332 if (digests_cnt == 1)
12333 opti_type |= OPTI_TYPE_SINGLE_HASH;
12334
12335 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12336 opti_type |= OPTI_TYPE_NOT_ITERATED;
12337
12338 if (attack_mode == ATTACK_MODE_BF)
12339 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12340
12341 data.opti_type = opti_type;
12342
12343 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12344 {
12345 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12346 {
12347 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12348 {
12349 if (opts_type & OPTS_TYPE_ST_ADD80)
12350 {
12351 opts_type &= ~OPTS_TYPE_ST_ADD80;
12352 opts_type |= OPTS_TYPE_PT_ADD80;
12353 }
12354
12355 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12356 {
12357 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12358 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12359 }
12360
12361 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12362 {
12363 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12364 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12365 }
12366 }
12367 }
12368 }
12369
12370 /**
12371 * Some algorithm, like descrypt, can benefit from JIT compilation
12372 */
12373
12374 int force_jit_compilation = -1;
12375
12376 if (hash_mode == 8900)
12377 {
12378 force_jit_compilation = 8900;
12379 }
12380 else if (hash_mode == 9300)
12381 {
12382 force_jit_compilation = 8900;
12383 }
12384 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12385 {
12386 force_jit_compilation = 1500;
12387 }
12388
12389 /**
12390 * generate bitmap tables
12391 */
12392
12393 const uint bitmap_shift1 = 5;
12394 const uint bitmap_shift2 = 13;
12395
12396 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12397
12398 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12399 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12400 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12401 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12402 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12403 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12404 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12405 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12406
12407 uint bitmap_bits;
12408 uint bitmap_nums;
12409 uint bitmap_mask;
12410 uint bitmap_size;
12411
12412 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12413 {
12414 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12415
12416 bitmap_nums = 1 << bitmap_bits;
12417
12418 bitmap_mask = bitmap_nums - 1;
12419
12420 bitmap_size = bitmap_nums * sizeof (uint);
12421
12422 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12423
12424 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;
12425 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;
12426
12427 break;
12428 }
12429
12430 bitmap_nums = 1 << bitmap_bits;
12431
12432 bitmap_mask = bitmap_nums - 1;
12433
12434 bitmap_size = bitmap_nums * sizeof (uint);
12435
12436 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);
12437 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);
12438
12439 /**
12440 * prepare quick rule
12441 */
12442
12443 data.rule_buf_l = rule_buf_l;
12444 data.rule_buf_r = rule_buf_r;
12445
12446 int rule_len_l = (int) strlen (rule_buf_l);
12447 int rule_len_r = (int) strlen (rule_buf_r);
12448
12449 data.rule_len_l = rule_len_l;
12450 data.rule_len_r = rule_len_r;
12451
12452 /**
12453 * load rules
12454 */
12455
12456 uint *all_kernel_rules_cnt = NULL;
12457
12458 kernel_rule_t **all_kernel_rules_buf = NULL;
12459
12460 if (rp_files_cnt)
12461 {
12462 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12463
12464 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12465 }
12466
12467 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12468
12469 int rule_len = 0;
12470
12471 for (uint i = 0; i < rp_files_cnt; i++)
12472 {
12473 uint kernel_rules_avail = 0;
12474
12475 uint kernel_rules_cnt = 0;
12476
12477 kernel_rule_t *kernel_rules_buf = NULL;
12478
12479 char *rp_file = rp_files[i];
12480
12481 char in[BLOCK_SIZE] = { 0 };
12482 char out[BLOCK_SIZE] = { 0 };
12483
12484 FILE *fp = NULL;
12485
12486 uint rule_line = 0;
12487
12488 if ((fp = fopen (rp_file, "rb")) == NULL)
12489 {
12490 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12491
12492 return (-1);
12493 }
12494
12495 while (!feof (fp))
12496 {
12497 memset (rule_buf, 0, HCBUFSIZ);
12498
12499 rule_len = fgetl (fp, rule_buf);
12500
12501 rule_line++;
12502
12503 if (rule_len == 0) continue;
12504
12505 if (rule_buf[0] == '#') continue;
12506
12507 if (kernel_rules_avail == kernel_rules_cnt)
12508 {
12509 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12510
12511 kernel_rules_avail += INCR_RULES;
12512 }
12513
12514 memset (in, 0, BLOCK_SIZE);
12515 memset (out, 0, BLOCK_SIZE);
12516
12517 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12518
12519 if (result == -1)
12520 {
12521 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12522
12523 continue;
12524 }
12525
12526 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12527 {
12528 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12529
12530 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12531
12532 continue;
12533 }
12534
12535 /* its so slow
12536 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12537 {
12538 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12539
12540 continue;
12541 }
12542 */
12543
12544 kernel_rules_cnt++;
12545 }
12546
12547 fclose (fp);
12548
12549 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12550
12551 all_kernel_rules_buf[i] = kernel_rules_buf;
12552 }
12553
12554 /**
12555 * merge rules or automatic rule generator
12556 */
12557
12558 uint kernel_rules_cnt = 0;
12559
12560 kernel_rule_t *kernel_rules_buf = NULL;
12561
12562 if (attack_mode == ATTACK_MODE_STRAIGHT)
12563 {
12564 if (rp_files_cnt)
12565 {
12566 kernel_rules_cnt = 1;
12567
12568 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12569
12570 repeats[0] = kernel_rules_cnt;
12571
12572 for (uint i = 0; i < rp_files_cnt; i++)
12573 {
12574 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12575
12576 repeats[i + 1] = kernel_rules_cnt;
12577 }
12578
12579 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12580
12581 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12582
12583 for (uint i = 0; i < kernel_rules_cnt; i++)
12584 {
12585 uint out_pos = 0;
12586
12587 kernel_rule_t *out = &kernel_rules_buf[i];
12588
12589 for (uint j = 0; j < rp_files_cnt; j++)
12590 {
12591 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12592 uint in_pos;
12593
12594 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12595
12596 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12597 {
12598 if (out_pos == RULES_MAX - 1)
12599 {
12600 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12601
12602 break;
12603 }
12604
12605 out->cmds[out_pos] = in->cmds[in_pos];
12606 }
12607 }
12608 }
12609
12610 local_free (repeats);
12611 }
12612 else if (rp_gen)
12613 {
12614 uint kernel_rules_avail = 0;
12615
12616 while (kernel_rules_cnt < rp_gen)
12617 {
12618 if (kernel_rules_avail == kernel_rules_cnt)
12619 {
12620 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12621
12622 kernel_rules_avail += INCR_RULES;
12623 }
12624
12625 memset (rule_buf, 0, HCBUFSIZ);
12626
12627 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12628
12629 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12630
12631 kernel_rules_cnt++;
12632 }
12633 }
12634 }
12635
12636 myfree (rule_buf);
12637
12638 /**
12639 * generate NOP rules
12640 */
12641
12642 if (kernel_rules_cnt == 0)
12643 {
12644 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12645
12646 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12647
12648 kernel_rules_cnt++;
12649 }
12650
12651 data.kernel_rules_cnt = kernel_rules_cnt;
12652 data.kernel_rules_buf = kernel_rules_buf;
12653
12654 /**
12655 * OpenCL platforms: detect
12656 */
12657
12658 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12659 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12660
12661 cl_uint platforms_cnt = 0;
12662 cl_uint platform_devices_cnt = 0;
12663
12664 if (keyspace == 0)
12665 {
12666 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12667
12668 if (platforms_cnt == 0)
12669 {
12670 log_error ("ERROR: No OpenCL compatible platform found");
12671
12672 return (-1);
12673 }
12674
12675 if (opencl_platforms_filter != (uint) -1)
12676 {
12677 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12678
12679 if (opencl_platforms_filter > platform_cnt_mask)
12680 {
12681 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12682
12683 return (-1);
12684 }
12685 }
12686 }
12687
12688 /**
12689 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12690 */
12691
12692 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12693 {
12694 cl_platform_id platform = platforms[platform_id];
12695
12696 char platform_vendor[INFOSZ] = { 0 };
12697
12698 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12699
12700 #ifdef HAVE_HWMON
12701 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12702 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12703 {
12704 // make sure that we do not directly control the fan for NVidia
12705
12706 gpu_temp_retain = 0;
12707
12708 data.gpu_temp_retain = gpu_temp_retain;
12709 }
12710 #endif // HAVE_NVML || HAVE_NVAPI
12711 #endif
12712 }
12713
12714 /**
12715 * OpenCL devices: simply push all devices from all platforms into the same device array
12716 */
12717
12718 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12719
12720 data.devices_param = devices_param;
12721
12722 uint devices_cnt = 0;
12723
12724 uint devices_active = 0;
12725
12726 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12727 {
12728 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12729
12730 cl_platform_id platform = platforms[platform_id];
12731
12732 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12733
12734 char platform_vendor[INFOSZ] = { 0 };
12735
12736 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12737
12738 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
12739 // this causes trouble with vendor id based macros
12740 // we'll assign generic to those without special optimization available
12741
12742 cl_uint vendor_id = 0;
12743
12744 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
12745 {
12746 vendor_id = VENDOR_ID_AMD;
12747 }
12748 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
12749 {
12750 vendor_id = VENDOR_ID_GENERIC;
12751 }
12752 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
12753 {
12754 vendor_id = VENDOR_ID_GENERIC;
12755 }
12756 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
12757 {
12758 vendor_id = VENDOR_ID_GENERIC;
12759 }
12760 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
12761 {
12762 vendor_id = VENDOR_ID_GENERIC;
12763 }
12764 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12765 {
12766 vendor_id = VENDOR_ID_NV;
12767 }
12768 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
12769 {
12770 vendor_id = VENDOR_ID_GENERIC;
12771 }
12772 else
12773 {
12774 vendor_id = VENDOR_ID_GENERIC;
12775 }
12776
12777 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12778 {
12779 size_t param_value_size = 0;
12780
12781 const uint device_id = devices_cnt;
12782
12783 hc_device_param_t *device_param = &data.devices_param[device_id];
12784
12785 device_param->vendor_id = vendor_id;
12786
12787 device_param->device = platform_devices[platform_devices_id];
12788
12789 device_param->device_id = device_id;
12790
12791 device_param->platform_devices_id = platform_devices_id;
12792
12793 // device_type
12794
12795 cl_device_type device_type;
12796
12797 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12798
12799 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12800
12801 device_param->device_type = device_type;
12802
12803 // device_name
12804
12805 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12806
12807 char *device_name = (char *) mymalloc (param_value_size);
12808
12809 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12810
12811 device_param->device_name = device_name;
12812
12813 // tuning db
12814
12815 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12816
12817 // device_version
12818
12819 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12820
12821 char *device_version = (char *) mymalloc (param_value_size);
12822
12823 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12824
12825 device_param->device_version = device_version;
12826
12827 // device_opencl_version
12828
12829 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12830
12831 char *device_opencl_version = (char *) mymalloc (param_value_size);
12832
12833 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12834
12835 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12836
12837 myfree (device_opencl_version);
12838
12839 // vector_width
12840
12841 cl_uint vector_width;
12842
12843 if (opencl_vector_width_chgd == 0)
12844 {
12845 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12846 {
12847 if (opti_type & OPTI_TYPE_USES_BITS_64)
12848 {
12849 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12850 }
12851 else
12852 {
12853 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12854 }
12855 }
12856 else
12857 {
12858 vector_width = (cl_uint) tuningdb_entry->vector_width;
12859 }
12860 }
12861 else
12862 {
12863 vector_width = opencl_vector_width;
12864 }
12865
12866 if (vector_width > 16) vector_width = 16;
12867
12868 device_param->vector_width = vector_width;
12869
12870 // max_compute_units
12871
12872 cl_uint device_processors;
12873
12874 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12875
12876 device_param->device_processors = device_processors;
12877
12878 // max_mem_alloc_size
12879
12880 cl_ulong device_maxmem_alloc;
12881
12882 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12883
12884 device_param->device_maxmem_alloc = device_maxmem_alloc;
12885
12886 // max_mem_alloc_size
12887
12888 cl_ulong device_global_mem;
12889
12890 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12891
12892 device_param->device_global_mem = device_global_mem;
12893
12894 // max_clock_frequency
12895
12896 cl_uint device_maxclock_frequency;
12897
12898 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12899
12900 device_param->device_maxclock_frequency = device_maxclock_frequency;
12901
12902 // skipped
12903
12904 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12905 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12906
12907 device_param->skipped = (skipped1 || skipped2);
12908
12909 // driver_version
12910 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12911
12912 char *driver_version = (char *) mymalloc (param_value_size);
12913
12914 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12915
12916 device_param->driver_version = driver_version;
12917
12918 // device_name_chksum
12919
12920 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12921
12922 #if __x86_64__
12923 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);
12924 #else
12925 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);
12926 #endif
12927
12928 uint device_name_digest[4] = { 0 };
12929
12930 md5_64 ((uint *) device_name_chksum, device_name_digest);
12931
12932 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12933
12934 device_param->device_name_chksum = device_name_chksum;
12935
12936 // device_processor_cores
12937
12938 if (device_type & CL_DEVICE_TYPE_CPU)
12939 {
12940 cl_uint device_processor_cores = 1;
12941
12942 device_param->device_processor_cores = device_processor_cores;
12943 }
12944
12945 if (device_type & CL_DEVICE_TYPE_GPU)
12946 {
12947 if (vendor_id == VENDOR_ID_AMD)
12948 {
12949 cl_uint device_processor_cores = 0;
12950
12951 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12952
12953 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12954
12955 device_param->device_processor_cores = device_processor_cores;
12956 }
12957 else if (vendor_id == VENDOR_ID_NV)
12958 {
12959 cl_uint kernel_exec_timeout = 0;
12960
12961 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12962
12963 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12964
12965 device_param->kernel_exec_timeout = kernel_exec_timeout;
12966
12967 cl_uint device_processor_cores = 0;
12968
12969 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12970
12971 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12972
12973 device_param->device_processor_cores = device_processor_cores;
12974
12975 cl_uint sm_minor = 0;
12976 cl_uint sm_major = 0;
12977
12978 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12979 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12980
12981 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12982 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12983
12984 device_param->sm_minor = sm_minor;
12985 device_param->sm_major = sm_major;
12986 }
12987 else
12988 {
12989 cl_uint device_processor_cores = 1;
12990
12991 device_param->device_processor_cores = device_processor_cores;
12992 }
12993 }
12994
12995 // display results
12996
12997 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12998 {
12999 if (device_param->skipped == 0)
13000 {
13001 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13002 device_id + 1,
13003 device_name,
13004 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13005 (unsigned int) (device_global_mem / 1024 / 1024),
13006 (unsigned int) (device_maxclock_frequency),
13007 (unsigned int) device_processors);
13008 }
13009 else
13010 {
13011 log_info ("Device #%u: %s, skipped",
13012 device_id + 1,
13013 device_name);
13014 }
13015 }
13016
13017 // common driver check
13018
13019 if (device_param->skipped == 0)
13020 {
13021 if (device_type & CL_DEVICE_TYPE_GPU)
13022 {
13023 if (vendor_id == VENDOR_ID_AMD)
13024 {
13025 int catalyst_check = (force == 1) ? 0 : 1;
13026
13027 int catalyst_warn = 0;
13028
13029 int catalyst_broken = 0;
13030
13031 if (catalyst_check == 1)
13032 {
13033 catalyst_warn = 1;
13034
13035 // v14.9 and higher
13036 if (atoi (device_param->driver_version) >= 1573)
13037 {
13038 catalyst_warn = 0;
13039 }
13040
13041 catalyst_check = 0;
13042 }
13043
13044 if (catalyst_broken == 1)
13045 {
13046 log_info ("");
13047 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13048 log_info ("It will pass over cracked hashes and does not report them as cracked");
13049 log_info ("You are STRONGLY encouraged not to use it");
13050 log_info ("You can use --force to override this but do not post error reports if you do so");
13051 log_info ("");
13052
13053 return (-1);
13054 }
13055
13056 if (catalyst_warn == 1)
13057 {
13058 log_info ("");
13059 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13060 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13061 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13062 #ifdef _WIN
13063 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13064 #endif
13065 log_info ("You can use --force to override this but do not post error reports if you do so");
13066 log_info ("");
13067
13068 return (-1);
13069 }
13070 }
13071 else if (vendor_id == VENDOR_ID_NV)
13072 {
13073 if (device_param->kernel_exec_timeout != 0)
13074 {
13075 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);
13076 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13077 }
13078 }
13079 else if (vendor_id == VENDOR_ID_POCL)
13080 {
13081 if (force == 0)
13082 {
13083 log_info ("");
13084 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
13085 log_info ("You are STRONGLY encouraged not to use it");
13086 log_info ("You can use --force to override this but do not post error reports if you do so");
13087 log_info ("");
13088
13089 return (-1);
13090 }
13091 }
13092 }
13093
13094 /**
13095 * kernel accel and loops tuning db adjustment
13096 */
13097
13098 device_param->kernel_accel_min = 1;
13099 device_param->kernel_accel_max = 1024;
13100
13101 device_param->kernel_loops_min = 1;
13102 device_param->kernel_loops_max = 1024;
13103
13104 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13105
13106 if (tuningdb_entry)
13107 {
13108 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13109 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13110
13111 if (_kernel_accel)
13112 {
13113 device_param->kernel_accel_min = _kernel_accel;
13114 device_param->kernel_accel_max = _kernel_accel;
13115 }
13116
13117 if (_kernel_loops)
13118 {
13119 if (workload_profile == 1)
13120 {
13121 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13122 }
13123 else if (workload_profile == 2)
13124 {
13125 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13126 }
13127
13128 device_param->kernel_loops_min = _kernel_loops;
13129 device_param->kernel_loops_max = _kernel_loops;
13130 }
13131 }
13132
13133 // commandline parameters overwrite tuningdb entries
13134
13135 if (kernel_accel)
13136 {
13137 device_param->kernel_accel_min = kernel_accel;
13138 device_param->kernel_accel_max = kernel_accel;
13139 }
13140
13141 if (kernel_loops)
13142 {
13143 device_param->kernel_loops_min = kernel_loops;
13144 device_param->kernel_loops_max = kernel_loops;
13145 }
13146
13147 /**
13148 * activate device
13149 */
13150
13151 devices_active++;
13152 }
13153
13154 // next please
13155
13156 devices_cnt++;
13157 }
13158 }
13159
13160 if (keyspace == 0 && devices_active == 0)
13161 {
13162 log_error ("ERROR: No devices found/left");
13163
13164 return (-1);
13165 }
13166
13167 // 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)
13168
13169 if (devices_filter != (uint) -1)
13170 {
13171 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13172
13173 if (devices_filter > devices_cnt_mask)
13174 {
13175 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13176
13177 return (-1);
13178 }
13179 }
13180
13181 data.devices_cnt = devices_cnt;
13182
13183 data.devices_active = devices_active;
13184
13185 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13186 {
13187 log_info ("");
13188 }
13189
13190 /**
13191 * HM devices: init
13192 */
13193
13194 #ifdef HAVE_HWMON
13195 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13196 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13197 #endif
13198
13199 #ifdef HAVE_ADL
13200 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13201 #endif
13202
13203 if (gpu_temp_disable == 0)
13204 {
13205 #if defined(WIN) && defined(HAVE_NVAPI)
13206 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13207
13208 if (nvapi_init (nvapi) == 0)
13209 data.hm_nv = nvapi;
13210
13211 if (data.hm_nv)
13212 {
13213 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13214 {
13215 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13216
13217 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13218
13219 int tmp_out = 0;
13220
13221 for (int i = 0; i < tmp_in; i++)
13222 {
13223 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13224 }
13225
13226 for (int i = 0; i < tmp_out; i++)
13227 {
13228 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13229
13230 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13231
13232 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;
13233 }
13234 }
13235 }
13236 #endif // WIN && HAVE_NVAPI
13237
13238 #if defined(LINUX) && defined(HAVE_NVML)
13239 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13240
13241 if (nvml_init (nvml) == 0)
13242 data.hm_nv = nvml;
13243
13244 if (data.hm_nv)
13245 {
13246 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13247 {
13248 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13249
13250 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13251
13252 int tmp_out = 0;
13253
13254 for (int i = 0; i < tmp_in; i++)
13255 {
13256 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13257 }
13258
13259 for (int i = 0; i < tmp_out; i++)
13260 {
13261 unsigned int speed;
13262
13263 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;
13264 }
13265 }
13266 }
13267 #endif // LINUX && HAVE_NVML
13268
13269 data.hm_amd = NULL;
13270
13271 #ifdef HAVE_ADL
13272 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13273
13274 if (adl_init (adl) == 0)
13275 data.hm_amd = adl;
13276
13277 if (data.hm_amd)
13278 {
13279 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13280 {
13281 // total number of adapters
13282
13283 int hm_adapters_num;
13284
13285 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13286
13287 // adapter info
13288
13289 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13290
13291 if (lpAdapterInfo == NULL) return (-1);
13292
13293 // get a list (of ids of) valid/usable adapters
13294
13295 int num_adl_adapters = 0;
13296
13297 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13298
13299 if (num_adl_adapters > 0)
13300 {
13301 hc_thread_mutex_lock (mux_adl);
13302
13303 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13304
13305 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13306
13307 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13308 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13309
13310 hc_thread_mutex_unlock (mux_adl);
13311 }
13312
13313 myfree (valid_adl_device_list);
13314 myfree (lpAdapterInfo);
13315 }
13316 }
13317 #endif // HAVE_ADL
13318
13319 if (data.hm_amd == NULL && data.hm_nv == NULL)
13320 {
13321 gpu_temp_disable = 1;
13322 }
13323 }
13324
13325 /**
13326 * OpenCL devices: allocate buffer for device specific information
13327 */
13328
13329 #ifdef HAVE_HWMON
13330 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13331
13332 #ifdef HAVE_ADL
13333 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13334
13335 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13336 #endif // ADL
13337 #endif
13338
13339 /**
13340 * enable custom signal handler(s)
13341 */
13342
13343 if (benchmark == 0)
13344 {
13345 hc_signal (sigHandler_default);
13346 }
13347 else
13348 {
13349 hc_signal (sigHandler_benchmark);
13350 }
13351
13352 /**
13353 * User-defined GPU temp handling
13354 */
13355
13356 #ifdef HAVE_HWMON
13357 if (gpu_temp_disable == 1)
13358 {
13359 gpu_temp_abort = 0;
13360 gpu_temp_retain = 0;
13361 }
13362
13363 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13364 {
13365 if (gpu_temp_abort < gpu_temp_retain)
13366 {
13367 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13368
13369 return (-1);
13370 }
13371 }
13372
13373 data.gpu_temp_disable = gpu_temp_disable;
13374 data.gpu_temp_abort = gpu_temp_abort;
13375 data.gpu_temp_retain = gpu_temp_retain;
13376 #endif
13377
13378 /**
13379 * inform the user
13380 */
13381
13382 if (data.quiet == 0)
13383 {
13384 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13385
13386 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);
13387
13388 if (attack_mode == ATTACK_MODE_STRAIGHT)
13389 {
13390 log_info ("Rules: %u", kernel_rules_cnt);
13391 }
13392
13393 if (opti_type)
13394 {
13395 log_info ("Applicable Optimizers:");
13396
13397 for (uint i = 0; i < 32; i++)
13398 {
13399 const uint opti_bit = 1u << i;
13400
13401 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13402 }
13403 }
13404
13405 /**
13406 * Watchdog and Temperature balance
13407 */
13408
13409 #ifdef HAVE_HWMON
13410 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13411 {
13412 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13413 }
13414
13415 if (gpu_temp_abort == 0)
13416 {
13417 log_info ("Watchdog: Temperature abort trigger disabled");
13418 }
13419 else
13420 {
13421 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13422 }
13423
13424 if (gpu_temp_retain == 0)
13425 {
13426 log_info ("Watchdog: Temperature retain trigger disabled");
13427 }
13428 else
13429 {
13430 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13431 }
13432 #endif
13433 }
13434
13435 if (data.quiet == 0) log_info ("");
13436
13437 /**
13438 * HM devices: copy
13439 */
13440
13441 if (gpu_temp_disable == 0)
13442 {
13443 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13444 {
13445 hc_device_param_t *device_param = &data.devices_param[device_id];
13446
13447 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13448
13449 if (device_param->skipped) continue;
13450
13451 const uint platform_devices_id = device_param->platform_devices_id;
13452
13453 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13454 if (device_param->vendor_id == VENDOR_ID_NV)
13455 {
13456 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13457 }
13458 #endif
13459
13460 #ifdef HAVE_ADL
13461 if (device_param->vendor_id == VENDOR_ID_AMD)
13462 {
13463 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13464 }
13465 #endif
13466 }
13467 }
13468
13469 /*
13470 * Temporary fix:
13471 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13472 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13473 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13474 * Driver / ADL bug?
13475 */
13476
13477 #ifdef HAVE_ADL
13478 if (powertune_enable == 1)
13479 {
13480 hc_thread_mutex_lock (mux_adl);
13481
13482 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13483 {
13484 hc_device_param_t *device_param = &data.devices_param[device_id];
13485
13486 if (device_param->skipped) continue;
13487
13488 if (data.hm_device[device_id].od_version == 6)
13489 {
13490 // set powertune value only
13491
13492 int powertune_supported = 0;
13493
13494 int ADL_rc = 0;
13495
13496 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13497 {
13498 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13499
13500 return (-1);
13501 }
13502
13503 if (powertune_supported != 0)
13504 {
13505 // powertune set
13506 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13507
13508 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13509 {
13510 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13511
13512 return (-1);
13513 }
13514
13515 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13516 {
13517 log_error ("ERROR: Failed to set new ADL PowerControl values");
13518
13519 return (-1);
13520 }
13521 }
13522 }
13523 }
13524
13525 hc_thread_mutex_unlock (mux_adl);
13526 }
13527 #endif // HAVE_ADK
13528 #endif // HAVE_HWMON
13529
13530 #ifdef DEBUG
13531 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13532 #endif
13533
13534 uint kernel_power_all = 0;
13535
13536 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13537 {
13538 /**
13539 * host buffer
13540 */
13541
13542 hc_device_param_t *device_param = &data.devices_param[device_id];
13543
13544 if (device_param->skipped) continue;
13545
13546 /**
13547 * device properties
13548 */
13549
13550 const char *device_name_chksum = device_param->device_name_chksum;
13551 const u32 device_processors = device_param->device_processors;
13552 const u32 device_processor_cores = device_param->device_processor_cores;
13553
13554 /**
13555 * create context for each device
13556 */
13557
13558 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13559
13560 /**
13561 * create command-queue
13562 */
13563
13564 // not supported with NV
13565 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13566
13567 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13568
13569 /**
13570 * create input buffers on device : calculate size of fixed memory buffers
13571 */
13572
13573 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13574 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13575
13576 device_param->size_root_css = size_root_css;
13577 device_param->size_markov_css = size_markov_css;
13578
13579 uint size_results = KERNEL_THREADS * sizeof (uint);
13580
13581 device_param->size_results = size_results;
13582
13583 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13584 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13585
13586 uint size_plains = digests_cnt * sizeof (plain_t);
13587 uint size_salts = salts_cnt * sizeof (salt_t);
13588 uint size_esalts = salts_cnt * esalt_size;
13589
13590 device_param->size_plains = size_plains;
13591 device_param->size_digests = size_digests;
13592 device_param->size_shown = size_shown;
13593 device_param->size_salts = size_salts;
13594
13595 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13596 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13597 uint size_tm = 32 * sizeof (bs_word_t);
13598
13599 // scryptV stuff
13600
13601 u64 size_scryptV = 1;
13602
13603 if ((hash_mode == 8900) || (hash_mode == 9300))
13604 {
13605 uint tmto_start = 0;
13606 uint tmto_stop = 10;
13607
13608 if (scrypt_tmto)
13609 {
13610 tmto_start = scrypt_tmto;
13611 }
13612 else
13613 {
13614 // in case the user did not specify the tmto manually
13615 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13616 // but set the lower end only in case the user has a device with too less memory
13617
13618 if (hash_mode == 8900)
13619 {
13620 if (device_param->vendor_id == VENDOR_ID_AMD)
13621 {
13622 tmto_start = 1;
13623 }
13624 else if (device_param->vendor_id == VENDOR_ID_NV)
13625 {
13626 tmto_start = 3;
13627 }
13628 }
13629 else if (hash_mode == 9300)
13630 {
13631 if (device_param->vendor_id == VENDOR_ID_AMD)
13632 {
13633 tmto_start = 3;
13634 }
13635 else if (device_param->vendor_id == VENDOR_ID_NV)
13636 {
13637 tmto_start = 5;
13638 }
13639 }
13640 }
13641
13642 if (quiet == 0) log_info ("");
13643
13644 uint shader_per_mp = 1;
13645
13646 if (device_param->vendor_id == VENDOR_ID_AMD)
13647 {
13648 shader_per_mp = 8;
13649 }
13650 else if (device_param->vendor_id == VENDOR_ID_NV)
13651 {
13652 shader_per_mp = 32;
13653 }
13654
13655 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13656 {
13657 // TODO: in theory the following calculation needs to be done per salt, not global
13658 // we assume all hashes have the same scrypt settings
13659
13660 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13661
13662 size_scryptV /= 1 << tmto;
13663
13664 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13665
13666 if (size_scryptV > device_param->device_maxmem_alloc)
13667 {
13668 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13669
13670 continue;
13671 }
13672
13673 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13674 {
13675 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13676 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13677 }
13678
13679 break;
13680 }
13681
13682 if (data.salts_buf[0].scrypt_phy == 0)
13683 {
13684 log_error ("ERROR: can't allocate enough device memory");
13685
13686 return -1;
13687 }
13688
13689 if (quiet == 0) log_info ("");
13690 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13691 }
13692
13693 /**
13694 * create input buffers on device : calculate size of dynamic size memory buffers
13695 */
13696
13697 uint kernel_threads = KERNEL_THREADS;
13698
13699 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13700
13701 if (hash_mode == 3200) kernel_threads = 8;
13702 if (hash_mode == 9000) kernel_threads = 8;
13703
13704 /**
13705 * some algorithms need a fixed kernel-loops count
13706 */
13707
13708 if (hash_mode == 1500)
13709 {
13710 const u32 kernel_loops_fixed = 1024;
13711
13712 device_param->kernel_loops_min = kernel_loops_fixed;
13713 device_param->kernel_loops_max = kernel_loops_fixed;
13714 }
13715
13716 if (hash_mode == 3000)
13717 {
13718 const u32 kernel_loops_fixed = 1024;
13719
13720 device_param->kernel_loops_min = kernel_loops_fixed;
13721 device_param->kernel_loops_max = kernel_loops_fixed;
13722 }
13723
13724 if (hash_mode == 8900)
13725 {
13726 const u32 kernel_loops_fixed = 1;
13727
13728 device_param->kernel_loops_min = kernel_loops_fixed;
13729 device_param->kernel_loops_max = kernel_loops_fixed;
13730 }
13731
13732 if (hash_mode == 9300)
13733 {
13734 const u32 kernel_loops_fixed = 1;
13735
13736 device_param->kernel_loops_min = kernel_loops_fixed;
13737 device_param->kernel_loops_max = kernel_loops_fixed;
13738 }
13739
13740 if (hash_mode == 12500)
13741 {
13742 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13743
13744 device_param->kernel_loops_min = kernel_loops_fixed;
13745 device_param->kernel_loops_max = kernel_loops_fixed;
13746 }
13747
13748 /**
13749 * some algorithms have a maximum kernel-loops count
13750 */
13751
13752 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13753 {
13754 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13755 {
13756 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13757 }
13758 }
13759
13760 /**
13761 * some algorithms need a special kernel-accel
13762 */
13763
13764 if (hash_mode == 8900)
13765 {
13766 device_param->kernel_accel_min = 1;
13767 device_param->kernel_accel_max = 64;
13768 }
13769
13770 if (hash_mode == 9300)
13771 {
13772 device_param->kernel_accel_min = 1;
13773 device_param->kernel_accel_max = 64;
13774 }
13775
13776 u32 kernel_accel_min = device_param->kernel_accel_min;
13777 u32 kernel_accel_max = device_param->kernel_accel_max;
13778
13779 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13780
13781 uint size_pws = 4;
13782 uint size_tmps = 4;
13783 uint size_hooks = 4;
13784
13785 while (kernel_accel_max >= kernel_accel_min)
13786 {
13787 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13788
13789 // size_pws
13790
13791 size_pws = kernel_power_max * sizeof (pw_t);
13792
13793 // size_tmps
13794
13795 switch (hash_mode)
13796 {
13797 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13798 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13799 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13800 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13801 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13802 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13803 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13804 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13805 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13806 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13807 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13808 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13809 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13810 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13811 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13812 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13813 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13814 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13815 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13816 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13817 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13818 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13819 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13820 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13821 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13822 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13823 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13824 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13825 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13826 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13827 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13828 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13829 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13830 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13831 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13832 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13833 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13834 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13835 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13836 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13837 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13838 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13839 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13840 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13841 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13842 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13843 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13844 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13845 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13846 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13847 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13848 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13849 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13850 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13851 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13852 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13853 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13854 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13855 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13856 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13857 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13858 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13859 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13860 };
13861
13862 // size_hooks
13863
13864 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13865 {
13866 // none yet
13867 }
13868
13869 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13870 // if not, decrease amplifier and try again
13871
13872 int skip = 0;
13873
13874 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13875 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13876 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13877
13878 if (( bitmap_size
13879 + bitmap_size
13880 + bitmap_size
13881 + bitmap_size
13882 + bitmap_size
13883 + bitmap_size
13884 + bitmap_size
13885 + bitmap_size
13886 + size_bfs
13887 + size_combs
13888 + size_digests
13889 + size_esalts
13890 + size_hooks
13891 + size_markov_css
13892 + size_plains
13893 + size_pws
13894 + size_results
13895 + size_root_css
13896 + size_rules
13897 + size_rules_c
13898 + size_salts
13899 + size_scryptV
13900 + size_shown
13901 + size_tm
13902 + size_tmps) > device_param->device_global_mem) skip = 1;
13903
13904 if (skip == 1)
13905 {
13906 kernel_accel_max--;
13907
13908 continue;
13909 }
13910
13911 break;
13912 }
13913
13914 /*
13915 if (kernel_accel_max == 0)
13916 {
13917 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13918
13919 return -1;
13920 }
13921 */
13922
13923 device_param->kernel_accel_min = kernel_accel_min;
13924 device_param->kernel_accel_max = kernel_accel_max;
13925
13926 /*
13927 if (kernel_accel_max < kernel_accel)
13928 {
13929 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13930
13931 device_param->kernel_accel = kernel_accel_max;
13932 }
13933 */
13934
13935 device_param->size_bfs = size_bfs;
13936 device_param->size_combs = size_combs;
13937 device_param->size_rules = size_rules;
13938 device_param->size_rules_c = size_rules_c;
13939 device_param->size_pws = size_pws;
13940 device_param->size_tmps = size_tmps;
13941 device_param->size_hooks = size_hooks;
13942
13943 // do not confuse kernel_accel_max with kernel_accel here
13944
13945 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13946
13947 device_param->kernel_threads = kernel_threads;
13948 device_param->kernel_power_user = kernel_power;
13949
13950 kernel_power_all += kernel_power;
13951
13952 /**
13953 * default building options
13954 */
13955
13956 char build_opts[1024] = { 0 };
13957
13958 // we don't have sm_* on vendors not NV but it doesn't matter
13959
13960 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);
13961
13962 /**
13963 * main kernel
13964 */
13965
13966 {
13967 /**
13968 * kernel source filename
13969 */
13970
13971 char source_file[256] = { 0 };
13972
13973 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13974
13975 struct stat sst;
13976
13977 if (stat (source_file, &sst) == -1)
13978 {
13979 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13980
13981 return -1;
13982 }
13983
13984 /**
13985 * kernel cached filename
13986 */
13987
13988 char cached_file[256] = { 0 };
13989
13990 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13991
13992 int cached = 1;
13993
13994 struct stat cst;
13995
13996 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13997 {
13998 cached = 0;
13999 }
14000
14001 /**
14002 * kernel compile or load
14003 */
14004
14005 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14006
14007 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14008
14009 if (force_jit_compilation == -1)
14010 {
14011 if (cached == 0)
14012 {
14013 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14014
14015 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14016
14017 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14018
14019 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14020
14021 #ifdef DEBUG
14022 size_t build_log_size = 0;
14023
14024 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14025
14026 if (build_log_size > 1)
14027 {
14028 char *build_log = (char *) malloc (build_log_size + 1);
14029
14030 memset (build_log, 0, build_log_size + 1);
14031
14032 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14033
14034 puts (build_log);
14035
14036 free (build_log);
14037 }
14038 #endif
14039
14040 if (rc != 0)
14041 {
14042 device_param->skipped = true;
14043 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14044 continue;
14045 }
14046
14047 size_t binary_size;
14048
14049 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14050
14051 u8 *binary = (u8 *) mymalloc (binary_size);
14052
14053 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14054
14055 writeProgramBin (cached_file, binary, binary_size);
14056
14057 local_free (binary);
14058 }
14059 else
14060 {
14061 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14062
14063 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14064
14065 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14066
14067 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14068 }
14069 }
14070 else
14071 {
14072 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14073
14074 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14075
14076 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14077
14078 char build_opts_update[1024] = { 0 };
14079
14080 if (force_jit_compilation == 1500)
14081 {
14082 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14083 }
14084 else if (force_jit_compilation == 8900)
14085 {
14086 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);
14087 }
14088 else
14089 {
14090 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14091 }
14092
14093 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14094
14095 #ifdef DEBUG
14096 size_t build_log_size = 0;
14097
14098 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14099
14100 if (build_log_size > 1)
14101 {
14102 char *build_log = (char *) malloc (build_log_size + 1);
14103
14104 memset (build_log, 0, build_log_size + 1);
14105
14106 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14107
14108 puts (build_log);
14109
14110 free (build_log);
14111 }
14112 #endif
14113
14114 if (rc != 0)
14115 {
14116 device_param->skipped = true;
14117
14118 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14119 }
14120 }
14121
14122 local_free (kernel_lengths);
14123 local_free (kernel_sources[0]);
14124 local_free (kernel_sources);
14125 }
14126
14127 /**
14128 * word generator kernel
14129 */
14130
14131 if (attack_mode != ATTACK_MODE_STRAIGHT)
14132 {
14133 /**
14134 * kernel mp source filename
14135 */
14136
14137 char source_file[256] = { 0 };
14138
14139 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14140
14141 struct stat sst;
14142
14143 if (stat (source_file, &sst) == -1)
14144 {
14145 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14146
14147 return -1;
14148 }
14149
14150 /**
14151 * kernel mp cached filename
14152 */
14153
14154 char cached_file[256] = { 0 };
14155
14156 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14157
14158 int cached = 1;
14159
14160 struct stat cst;
14161
14162 if (stat (cached_file, &cst) == -1)
14163 {
14164 cached = 0;
14165 }
14166
14167 /**
14168 * kernel compile or load
14169 */
14170
14171 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14172
14173 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14174
14175 if (cached == 0)
14176 {
14177 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14178
14179 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14180
14181 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14182
14183 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14184
14185 if (rc != 0)
14186 {
14187 device_param->skipped = true;
14188 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14189 continue;
14190 }
14191
14192 size_t binary_size;
14193
14194 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14195
14196 u8 *binary = (u8 *) mymalloc (binary_size);
14197
14198 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14199
14200 writeProgramBin (cached_file, binary, binary_size);
14201
14202 local_free (binary);
14203 }
14204 else
14205 {
14206 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14207
14208 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14209
14210 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14211
14212 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14213 }
14214
14215 local_free (kernel_lengths);
14216 local_free (kernel_sources[0]);
14217 local_free (kernel_sources);
14218 }
14219
14220 /**
14221 * amplifier kernel
14222 */
14223
14224 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14225 {
14226
14227 }
14228 else
14229 {
14230 /**
14231 * kernel amp source filename
14232 */
14233
14234 char source_file[256] = { 0 };
14235
14236 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14237
14238 struct stat sst;
14239
14240 if (stat (source_file, &sst) == -1)
14241 {
14242 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14243
14244 return -1;
14245 }
14246
14247 /**
14248 * kernel amp cached filename
14249 */
14250
14251 char cached_file[256] = { 0 };
14252
14253 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14254
14255 int cached = 1;
14256
14257 struct stat cst;
14258
14259 if (stat (cached_file, &cst) == -1)
14260 {
14261 cached = 0;
14262 }
14263
14264 /**
14265 * kernel compile or load
14266 */
14267
14268 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14269
14270 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14271
14272 if (cached == 0)
14273 {
14274 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14275
14276 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14277
14278 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14279
14280 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14281
14282 if (rc != 0)
14283 {
14284 device_param->skipped = true;
14285 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14286 continue;
14287 }
14288
14289 size_t binary_size;
14290
14291 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14292
14293 u8 *binary = (u8 *) mymalloc (binary_size);
14294
14295 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14296
14297 writeProgramBin (cached_file, binary, binary_size);
14298
14299 local_free (binary);
14300 }
14301 else
14302 {
14303 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14304
14305 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14306
14307 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14308
14309 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14310 }
14311
14312 local_free (kernel_lengths);
14313 local_free (kernel_sources[0]);
14314 local_free (kernel_sources);
14315 }
14316
14317 // some algorithm collide too fast, make that impossible
14318
14319 if (benchmark == 1)
14320 {
14321 ((uint *) digests_buf)[0] = -1;
14322 ((uint *) digests_buf)[1] = -1;
14323 ((uint *) digests_buf)[2] = -1;
14324 ((uint *) digests_buf)[3] = -1;
14325 }
14326
14327 /**
14328 * global buffers
14329 */
14330
14331 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14332 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14333 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14334 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14335 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14336 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14337 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14338 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14339 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14340 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14341 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14342 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14343 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14344 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14345 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14346 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14347 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14348 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14349
14350 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);
14351 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);
14352 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);
14353 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);
14354 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);
14355 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);
14356 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);
14357 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);
14358 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14359 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14360 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14361
14362 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14363 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14364 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14365 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14366 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14367 run_kernel_bzero (device_param, device_param->d_result, size_results);
14368
14369 /**
14370 * special buffers
14371 */
14372
14373 if (attack_kern == ATTACK_KERN_STRAIGHT)
14374 {
14375 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14376 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14377
14378 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14379
14380 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14381 }
14382 else if (attack_kern == ATTACK_KERN_COMBI)
14383 {
14384 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14385 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14386 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14387 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14388
14389 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14390 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14391 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14392 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14393 }
14394 else if (attack_kern == ATTACK_KERN_BF)
14395 {
14396 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14397 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14398 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14399 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14400 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14401
14402 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14403 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14404 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14405 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14406 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14407 }
14408
14409 if (size_esalts)
14410 {
14411 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14412
14413 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14414 }
14415
14416 /**
14417 * main host data
14418 */
14419
14420 uint *result = (uint *) mymalloc (size_results);
14421
14422 device_param->result = result;
14423
14424 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14425
14426 device_param->pws_buf = pws_buf;
14427
14428 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14429
14430 device_param->combs_buf = combs_buf;
14431
14432 void *hooks_buf = mymalloc (size_hooks);
14433
14434 device_param->hooks_buf = hooks_buf;
14435
14436 /**
14437 * kernel args
14438 */
14439
14440 device_param->kernel_params_buf32[21] = bitmap_mask;
14441 device_param->kernel_params_buf32[22] = bitmap_shift1;
14442 device_param->kernel_params_buf32[23] = bitmap_shift2;
14443 device_param->kernel_params_buf32[24] = 0; // salt_pos
14444 device_param->kernel_params_buf32[25] = 0; // loop_pos
14445 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14446 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14447 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14448 device_param->kernel_params_buf32[29] = 0; // digests_offset
14449 device_param->kernel_params_buf32[30] = 0; // combs_mode
14450 device_param->kernel_params_buf32[31] = 0; // gid_max
14451
14452 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14453 ? &device_param->d_pws_buf
14454 : &device_param->d_pws_amp_buf;
14455 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14456 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14457 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14458 device_param->kernel_params[ 4] = &device_param->d_tmps;
14459 device_param->kernel_params[ 5] = &device_param->d_hooks;
14460 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14461 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14462 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14463 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14464 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14465 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14466 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14467 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14468 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14469 device_param->kernel_params[15] = &device_param->d_digests_buf;
14470 device_param->kernel_params[16] = &device_param->d_digests_shown;
14471 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14472 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14473 device_param->kernel_params[19] = &device_param->d_result;
14474 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14475 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14476 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14477 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14478 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14479 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14480 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14481 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14482 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14483 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14484 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14485 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14486
14487 device_param->kernel_params_mp_buf64[3] = 0;
14488 device_param->kernel_params_mp_buf32[4] = 0;
14489 device_param->kernel_params_mp_buf32[5] = 0;
14490 device_param->kernel_params_mp_buf32[6] = 0;
14491 device_param->kernel_params_mp_buf32[7] = 0;
14492 device_param->kernel_params_mp_buf32[8] = 0;
14493
14494 device_param->kernel_params_mp[0] = NULL;
14495 device_param->kernel_params_mp[1] = NULL;
14496 device_param->kernel_params_mp[2] = NULL;
14497 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14498 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14499 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14500 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14501 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14502 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14503
14504 device_param->kernel_params_mp_l_buf64[3] = 0;
14505 device_param->kernel_params_mp_l_buf32[4] = 0;
14506 device_param->kernel_params_mp_l_buf32[5] = 0;
14507 device_param->kernel_params_mp_l_buf32[6] = 0;
14508 device_param->kernel_params_mp_l_buf32[7] = 0;
14509 device_param->kernel_params_mp_l_buf32[8] = 0;
14510 device_param->kernel_params_mp_l_buf32[9] = 0;
14511
14512 device_param->kernel_params_mp_l[0] = NULL;
14513 device_param->kernel_params_mp_l[1] = NULL;
14514 device_param->kernel_params_mp_l[2] = NULL;
14515 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14516 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14517 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14518 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14519 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14520 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14521 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14522
14523 device_param->kernel_params_mp_r_buf64[3] = 0;
14524 device_param->kernel_params_mp_r_buf32[4] = 0;
14525 device_param->kernel_params_mp_r_buf32[5] = 0;
14526 device_param->kernel_params_mp_r_buf32[6] = 0;
14527 device_param->kernel_params_mp_r_buf32[7] = 0;
14528 device_param->kernel_params_mp_r_buf32[8] = 0;
14529
14530 device_param->kernel_params_mp_r[0] = NULL;
14531 device_param->kernel_params_mp_r[1] = NULL;
14532 device_param->kernel_params_mp_r[2] = NULL;
14533 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14534 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14535 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14536 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14537 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14538 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14539
14540 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14541 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14542
14543 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14544 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14545 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14546 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14547 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14548 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14549 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14550
14551 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14552 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14553
14554 /**
14555 * kernel name
14556 */
14557
14558 char kernel_name[64] = { 0 };
14559
14560 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14561 {
14562 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14563 {
14564 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14565
14566 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14567
14568 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14569
14570 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14571
14572 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14573
14574 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14575 }
14576 else
14577 {
14578 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14579
14580 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14581
14582 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14583
14584 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14585
14586 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14587
14588 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14589 }
14590
14591 if (data.attack_mode == ATTACK_MODE_BF)
14592 {
14593 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14594 {
14595 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14596
14597 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14598 }
14599 }
14600 }
14601 else
14602 {
14603 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14604
14605 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14606
14607 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14608
14609 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14610
14611 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14612
14613 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14614
14615 if (opts_type & OPTS_TYPE_HOOK12)
14616 {
14617 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14618
14619 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14620 }
14621
14622 if (opts_type & OPTS_TYPE_HOOK23)
14623 {
14624 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14625
14626 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14627 }
14628 }
14629
14630 for (uint i = 0; i <= 20; i++)
14631 {
14632 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14633 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14634 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14635
14636 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14637 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14638 }
14639
14640 for (uint i = 21; i <= 31; i++)
14641 {
14642 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14643 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14644 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14645
14646 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14647 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14648 }
14649
14650 if (attack_mode == ATTACK_MODE_BF)
14651 {
14652 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14653 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14654
14655 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14656 {
14657 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14658 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14659 }
14660 }
14661 else if (attack_mode == ATTACK_MODE_HYBRID1)
14662 {
14663 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14664 }
14665 else if (attack_mode == ATTACK_MODE_HYBRID2)
14666 {
14667 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14668 }
14669
14670 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14671 {
14672 // nothing to do
14673 }
14674 else
14675 {
14676 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14677 }
14678
14679 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14680 {
14681 // nothing to do
14682 }
14683 else
14684 {
14685 for (uint i = 0; i < 5; i++)
14686 {
14687 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14688 }
14689
14690 for (uint i = 5; i < 7; i++)
14691 {
14692 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14693 }
14694 }
14695
14696 /**
14697 * Store initial fanspeed if gpu_temp_retain is enabled
14698 */
14699
14700 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14701 int gpu_temp_retain_set = 0;
14702
14703 if (gpu_temp_disable == 0)
14704 {
14705 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14706 {
14707 hc_thread_mutex_lock (mux_adl);
14708
14709 if (data.hm_device[device_id].fan_supported == 1)
14710 {
14711 if (gpu_temp_retain_chgd == 0)
14712 {
14713 uint cur_temp = 0;
14714 uint default_temp = 0;
14715
14716 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);
14717
14718 if (ADL_rc == ADL_OK)
14719 {
14720 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14721
14722 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14723
14724 // special case with multi gpu setups: always use minimum retain
14725
14726 if (gpu_temp_retain_set == 0)
14727 {
14728 gpu_temp_retain = gpu_temp_retain_target;
14729 gpu_temp_retain_set = 1;
14730 }
14731 else
14732 {
14733 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14734 }
14735
14736 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14737 }
14738 }
14739
14740 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14741
14742 temp_retain_fanspeed_value[device_id] = fan_speed;
14743
14744 if (fan_speed == -1)
14745 {
14746 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14747
14748 temp_retain_fanspeed_value[device_id] = 0;
14749 }
14750 }
14751
14752 hc_thread_mutex_unlock (mux_adl);
14753 }
14754 }
14755
14756 /**
14757 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14758 */
14759
14760 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14761 {
14762 hc_thread_mutex_lock (mux_adl);
14763
14764 if (data.hm_device[device_id].od_version == 6)
14765 {
14766 int ADL_rc;
14767
14768 // check powertune capabilities first, if not available then skip device
14769
14770 int powertune_supported = 0;
14771
14772 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14773 {
14774 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14775
14776 return (-1);
14777 }
14778
14779 if (powertune_supported != 0)
14780 {
14781 // powercontrol settings
14782
14783 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14784
14785 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14786 {
14787 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14788 }
14789
14790 if (ADL_rc != ADL_OK)
14791 {
14792 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14793
14794 return (-1);
14795 }
14796
14797 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14798 {
14799 log_error ("ERROR: Failed to set new ADL PowerControl values");
14800
14801 return (-1);
14802 }
14803
14804 // clocks
14805
14806 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14807
14808 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14809
14810 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)
14811 {
14812 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14813
14814 return (-1);
14815 }
14816
14817 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14818
14819 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14820
14821 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14822 {
14823 log_error ("ERROR: Failed to get ADL device capabilities");
14824
14825 return (-1);
14826 }
14827
14828 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14829 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14830
14831 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14832 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14833
14834 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14835 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14836
14837 // warning if profile has too low max values
14838
14839 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14840 {
14841 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14842 }
14843
14844 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14845 {
14846 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14847 }
14848
14849 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14850
14851 performance_state->iNumberOfPerformanceLevels = 2;
14852
14853 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14854 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14855 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14856 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14857
14858 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)
14859 {
14860 log_info ("ERROR: Failed to set ADL performance state");
14861
14862 return (-1);
14863 }
14864
14865 local_free (performance_state);
14866 }
14867 }
14868
14869 hc_thread_mutex_unlock (mux_adl);
14870 }
14871 #endif // HAVE_HWMON && HAVE_ADL
14872 }
14873
14874 data.kernel_power_all = kernel_power_all;
14875
14876 if (data.quiet == 0) log_info ("");
14877
14878 /**
14879 * In benchmark-mode, inform user which algorithm is checked
14880 */
14881
14882 if (benchmark == 1)
14883 {
14884 quiet = 0;
14885
14886 data.quiet = quiet;
14887
14888 char *hash_type = strhashtype (data.hash_mode); // not a bug
14889
14890 log_info ("Hashtype: %s", hash_type);
14891 log_info ("");
14892 }
14893
14894 /**
14895 * keep track of the progress
14896 */
14897
14898 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14899 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14900 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14901
14902 /**
14903 * open filehandles
14904 */
14905
14906 #if _WIN
14907 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14908 {
14909 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14910
14911 return (-1);
14912 }
14913
14914 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14915 {
14916 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14917
14918 return (-1);
14919 }
14920
14921 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14922 {
14923 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14924
14925 return (-1);
14926 }
14927 #endif
14928
14929 /**
14930 * dictionary pad
14931 */
14932
14933 segment_size *= (1024 * 1024);
14934
14935 data.segment_size = segment_size;
14936
14937 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14938
14939 wl_data->buf = (char *) mymalloc (segment_size);
14940 wl_data->avail = segment_size;
14941 wl_data->incr = segment_size;
14942 wl_data->cnt = 0;
14943 wl_data->pos = 0;
14944
14945 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14946
14947 data.wordlist_mode = wordlist_mode;
14948
14949 cs_t *css_buf = NULL;
14950 uint css_cnt = 0;
14951 uint dictcnt = 0;
14952 uint maskcnt = 1;
14953 char **masks = NULL;
14954 char **dictfiles = NULL;
14955
14956 uint mask_from_file = 0;
14957
14958 if (attack_mode == ATTACK_MODE_STRAIGHT)
14959 {
14960 if (wordlist_mode == WL_MODE_FILE)
14961 {
14962 int wls_left = myargc - (optind + 1);
14963
14964 for (int i = 0; i < wls_left; i++)
14965 {
14966 char *l0_filename = myargv[optind + 1 + i];
14967
14968 struct stat l0_stat;
14969
14970 if (stat (l0_filename, &l0_stat) == -1)
14971 {
14972 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14973
14974 return (-1);
14975 }
14976
14977 uint is_dir = S_ISDIR (l0_stat.st_mode);
14978
14979 if (is_dir == 0)
14980 {
14981 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14982
14983 dictcnt++;
14984
14985 dictfiles[dictcnt - 1] = l0_filename;
14986 }
14987 else
14988 {
14989 // do not allow --keyspace w/ a directory
14990
14991 if (keyspace == 1)
14992 {
14993 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14994
14995 return (-1);
14996 }
14997
14998 char **dictionary_files = NULL;
14999
15000 dictionary_files = scan_directory (l0_filename);
15001
15002 if (dictionary_files != NULL)
15003 {
15004 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15005
15006 for (int d = 0; dictionary_files[d] != NULL; d++)
15007 {
15008 char *l1_filename = dictionary_files[d];
15009
15010 struct stat l1_stat;
15011
15012 if (stat (l1_filename, &l1_stat) == -1)
15013 {
15014 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15015
15016 return (-1);
15017 }
15018
15019 if (S_ISREG (l1_stat.st_mode))
15020 {
15021 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15022
15023 dictcnt++;
15024
15025 dictfiles[dictcnt - 1] = strdup (l1_filename);
15026 }
15027 }
15028 }
15029
15030 local_free (dictionary_files);
15031 }
15032 }
15033
15034 if (dictcnt < 1)
15035 {
15036 log_error ("ERROR: No usable dictionary file found.");
15037
15038 return (-1);
15039 }
15040 }
15041 else if (wordlist_mode == WL_MODE_STDIN)
15042 {
15043 dictcnt = 1;
15044 }
15045 }
15046 else if (attack_mode == ATTACK_MODE_COMBI)
15047 {
15048 // display
15049
15050 char *dictfile1 = myargv[optind + 1 + 0];
15051 char *dictfile2 = myargv[optind + 1 + 1];
15052
15053 // find the bigger dictionary and use as base
15054
15055 FILE *fp1 = NULL;
15056 FILE *fp2 = NULL;
15057
15058 struct stat tmp_stat;
15059
15060 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15061 {
15062 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15063
15064 return (-1);
15065 }
15066
15067 if (stat (dictfile1, &tmp_stat) == -1)
15068 {
15069 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15070
15071 fclose (fp1);
15072
15073 return (-1);
15074 }
15075
15076 if (S_ISDIR (tmp_stat.st_mode))
15077 {
15078 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15079
15080 fclose (fp1);
15081
15082 return (-1);
15083 }
15084
15085 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15086 {
15087 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15088
15089 fclose (fp1);
15090
15091 return (-1);
15092 }
15093
15094 if (stat (dictfile2, &tmp_stat) == -1)
15095 {
15096 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15097
15098 fclose (fp1);
15099 fclose (fp2);
15100
15101 return (-1);
15102 }
15103
15104 if (S_ISDIR (tmp_stat.st_mode))
15105 {
15106 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15107
15108 fclose (fp1);
15109 fclose (fp2);
15110
15111 return (-1);
15112 }
15113
15114 data.combs_cnt = 1;
15115
15116 data.quiet = 1;
15117
15118 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15119
15120 data.quiet = quiet;
15121
15122 if (words1_cnt == 0)
15123 {
15124 log_error ("ERROR: %s: empty file", dictfile1);
15125
15126 fclose (fp1);
15127 fclose (fp2);
15128
15129 return (-1);
15130 }
15131
15132 data.combs_cnt = 1;
15133
15134 data.quiet = 1;
15135
15136 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15137
15138 data.quiet = quiet;
15139
15140 if (words2_cnt == 0)
15141 {
15142 log_error ("ERROR: %s: empty file", dictfile2);
15143
15144 fclose (fp1);
15145 fclose (fp2);
15146
15147 return (-1);
15148 }
15149
15150 fclose (fp1);
15151 fclose (fp2);
15152
15153 data.dictfile = dictfile1;
15154 data.dictfile2 = dictfile2;
15155
15156 if (words1_cnt >= words2_cnt)
15157 {
15158 data.combs_cnt = words2_cnt;
15159 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15160
15161 dictfiles = &data.dictfile;
15162
15163 dictcnt = 1;
15164 }
15165 else
15166 {
15167 data.combs_cnt = words1_cnt;
15168 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15169
15170 dictfiles = &data.dictfile2;
15171
15172 dictcnt = 1;
15173
15174 // we also have to switch wordlist related rules!
15175
15176 char *tmpc = data.rule_buf_l;
15177
15178 data.rule_buf_l = data.rule_buf_r;
15179 data.rule_buf_r = tmpc;
15180
15181 int tmpi = data.rule_len_l;
15182
15183 data.rule_len_l = data.rule_len_r;
15184 data.rule_len_r = tmpi;
15185 }
15186 }
15187 else if (attack_mode == ATTACK_MODE_BF)
15188 {
15189 char *mask = NULL;
15190
15191 maskcnt = 0;
15192
15193 if (benchmark == 0)
15194 {
15195 mask = myargv[optind + 1];
15196
15197 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15198
15199 if ((optind + 2) <= myargc)
15200 {
15201 struct stat file_stat;
15202
15203 if (stat (mask, &file_stat) == -1)
15204 {
15205 maskcnt = 1;
15206
15207 masks[maskcnt - 1] = mystrdup (mask);
15208 }
15209 else
15210 {
15211 int wls_left = myargc - (optind + 1);
15212
15213 uint masks_avail = INCR_MASKS;
15214
15215 for (int i = 0; i < wls_left; i++)
15216 {
15217 if (i != 0)
15218 {
15219 mask = myargv[optind + 1 + i];
15220
15221 if (stat (mask, &file_stat) == -1)
15222 {
15223 log_error ("ERROR: %s: %s", mask, strerror (errno));
15224
15225 return (-1);
15226 }
15227 }
15228
15229 uint is_file = S_ISREG (file_stat.st_mode);
15230
15231 if (is_file == 1)
15232 {
15233 FILE *mask_fp;
15234
15235 if ((mask_fp = fopen (mask, "r")) == NULL)
15236 {
15237 log_error ("ERROR: %s: %s", mask, strerror (errno));
15238
15239 return (-1);
15240 }
15241
15242 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15243
15244 while (!feof (mask_fp))
15245 {
15246 memset (line_buf, 0, HCBUFSIZ);
15247
15248 int line_len = fgetl (mask_fp, line_buf);
15249
15250 if (line_len == 0) continue;
15251
15252 if (line_buf[0] == '#') continue;
15253
15254 if (masks_avail == maskcnt)
15255 {
15256 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15257
15258 masks_avail += INCR_MASKS;
15259 }
15260
15261 masks[maskcnt] = mystrdup (line_buf);
15262
15263 maskcnt++;
15264 }
15265
15266 myfree (line_buf);
15267
15268 fclose (mask_fp);
15269 }
15270 else
15271 {
15272 log_error ("ERROR: %s: unsupported file-type", mask);
15273
15274 return (-1);
15275 }
15276 }
15277
15278 mask_from_file = 1;
15279 }
15280 }
15281 else
15282 {
15283 custom_charset_1 = (char *) "?l?d?u";
15284 custom_charset_2 = (char *) "?l?d";
15285 custom_charset_3 = (char *) "?l?d*!$@_";
15286
15287 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15288 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15289 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15290
15291 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15292
15293 wordlist_mode = WL_MODE_MASK;
15294
15295 data.wordlist_mode = wordlist_mode;
15296
15297 increment = 1;
15298
15299 maskcnt = 1;
15300 }
15301 }
15302 else
15303 {
15304 /**
15305 * generate full masks and charsets
15306 */
15307
15308 masks = (char **) mymalloc (sizeof (char *));
15309
15310 switch (hash_mode)
15311 {
15312 case 1731: pw_min = 5;
15313 pw_max = 5;
15314 mask = mystrdup ("?b?b?b?b?b");
15315 break;
15316 case 12500: pw_min = 5;
15317 pw_max = 5;
15318 mask = mystrdup ("?b?b?b?b?b");
15319 break;
15320 default: pw_min = 7;
15321 pw_max = 7;
15322 mask = mystrdup ("?b?b?b?b?b?b?b");
15323 break;
15324 }
15325
15326 maskcnt = 1;
15327
15328 masks[maskcnt - 1] = mystrdup (mask);
15329
15330 wordlist_mode = WL_MODE_MASK;
15331
15332 data.wordlist_mode = wordlist_mode;
15333
15334 increment = 1;
15335 }
15336
15337 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15338
15339 if (increment)
15340 {
15341 if (increment_min > pw_min) pw_min = increment_min;
15342
15343 if (increment_max < pw_max) pw_max = increment_max;
15344 }
15345 }
15346 else if (attack_mode == ATTACK_MODE_HYBRID1)
15347 {
15348 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15349
15350 // display
15351
15352 char *mask = myargv[myargc - 1];
15353
15354 maskcnt = 0;
15355
15356 masks = (char **) mymalloc (1 * sizeof (char *));
15357
15358 // mod
15359
15360 struct stat file_stat;
15361
15362 if (stat (mask, &file_stat) == -1)
15363 {
15364 maskcnt = 1;
15365
15366 masks[maskcnt - 1] = mystrdup (mask);
15367 }
15368 else
15369 {
15370 uint is_file = S_ISREG (file_stat.st_mode);
15371
15372 if (is_file == 1)
15373 {
15374 FILE *mask_fp;
15375
15376 if ((mask_fp = fopen (mask, "r")) == NULL)
15377 {
15378 log_error ("ERROR: %s: %s", mask, strerror (errno));
15379
15380 return (-1);
15381 }
15382
15383 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15384
15385 uint masks_avail = 1;
15386
15387 while (!feof (mask_fp))
15388 {
15389 memset (line_buf, 0, HCBUFSIZ);
15390
15391 int line_len = fgetl (mask_fp, line_buf);
15392
15393 if (line_len == 0) continue;
15394
15395 if (line_buf[0] == '#') continue;
15396
15397 if (masks_avail == maskcnt)
15398 {
15399 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15400
15401 masks_avail += INCR_MASKS;
15402 }
15403
15404 masks[maskcnt] = mystrdup (line_buf);
15405
15406 maskcnt++;
15407 }
15408
15409 myfree (line_buf);
15410
15411 fclose (mask_fp);
15412
15413 mask_from_file = 1;
15414 }
15415 else
15416 {
15417 maskcnt = 1;
15418
15419 masks[maskcnt - 1] = mystrdup (mask);
15420 }
15421 }
15422
15423 // base
15424
15425 int wls_left = myargc - (optind + 2);
15426
15427 for (int i = 0; i < wls_left; i++)
15428 {
15429 char *filename = myargv[optind + 1 + i];
15430
15431 struct stat file_stat;
15432
15433 if (stat (filename, &file_stat) == -1)
15434 {
15435 log_error ("ERROR: %s: %s", filename, strerror (errno));
15436
15437 return (-1);
15438 }
15439
15440 uint is_dir = S_ISDIR (file_stat.st_mode);
15441
15442 if (is_dir == 0)
15443 {
15444 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15445
15446 dictcnt++;
15447
15448 dictfiles[dictcnt - 1] = filename;
15449 }
15450 else
15451 {
15452 // do not allow --keyspace w/ a directory
15453
15454 if (keyspace == 1)
15455 {
15456 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15457
15458 return (-1);
15459 }
15460
15461 char **dictionary_files = NULL;
15462
15463 dictionary_files = scan_directory (filename);
15464
15465 if (dictionary_files != NULL)
15466 {
15467 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15468
15469 for (int d = 0; dictionary_files[d] != NULL; d++)
15470 {
15471 char *l1_filename = dictionary_files[d];
15472
15473 struct stat l1_stat;
15474
15475 if (stat (l1_filename, &l1_stat) == -1)
15476 {
15477 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15478
15479 return (-1);
15480 }
15481
15482 if (S_ISREG (l1_stat.st_mode))
15483 {
15484 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15485
15486 dictcnt++;
15487
15488 dictfiles[dictcnt - 1] = strdup (l1_filename);
15489 }
15490 }
15491 }
15492
15493 local_free (dictionary_files);
15494 }
15495 }
15496
15497 if (dictcnt < 1)
15498 {
15499 log_error ("ERROR: No usable dictionary file found.");
15500
15501 return (-1);
15502 }
15503
15504 if (increment)
15505 {
15506 maskcnt = 0;
15507
15508 uint mask_min = increment_min; // we can't reject smaller masks here
15509 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15510
15511 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15512 {
15513 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15514
15515 if (cur_mask == NULL) break;
15516
15517 masks[maskcnt] = cur_mask;
15518
15519 maskcnt++;
15520
15521 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15522 }
15523 }
15524 }
15525 else if (attack_mode == ATTACK_MODE_HYBRID2)
15526 {
15527 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15528
15529 // display
15530
15531 char *mask = myargv[optind + 1 + 0];
15532
15533 maskcnt = 0;
15534
15535 masks = (char **) mymalloc (1 * sizeof (char *));
15536
15537 // mod
15538
15539 struct stat file_stat;
15540
15541 if (stat (mask, &file_stat) == -1)
15542 {
15543 maskcnt = 1;
15544
15545 masks[maskcnt - 1] = mystrdup (mask);
15546 }
15547 else
15548 {
15549 uint is_file = S_ISREG (file_stat.st_mode);
15550
15551 if (is_file == 1)
15552 {
15553 FILE *mask_fp;
15554
15555 if ((mask_fp = fopen (mask, "r")) == NULL)
15556 {
15557 log_error ("ERROR: %s: %s", mask, strerror (errno));
15558
15559 return (-1);
15560 }
15561
15562 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15563
15564 uint masks_avail = 1;
15565
15566 while (!feof (mask_fp))
15567 {
15568 memset (line_buf, 0, HCBUFSIZ);
15569
15570 int line_len = fgetl (mask_fp, line_buf);
15571
15572 if (line_len == 0) continue;
15573
15574 if (line_buf[0] == '#') continue;
15575
15576 if (masks_avail == maskcnt)
15577 {
15578 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15579
15580 masks_avail += INCR_MASKS;
15581 }
15582
15583 masks[maskcnt] = mystrdup (line_buf);
15584
15585 maskcnt++;
15586 }
15587
15588 myfree (line_buf);
15589
15590 fclose (mask_fp);
15591
15592 mask_from_file = 1;
15593 }
15594 else
15595 {
15596 maskcnt = 1;
15597
15598 masks[maskcnt - 1] = mystrdup (mask);
15599 }
15600 }
15601
15602 // base
15603
15604 int wls_left = myargc - (optind + 2);
15605
15606 for (int i = 0; i < wls_left; i++)
15607 {
15608 char *filename = myargv[optind + 2 + i];
15609
15610 struct stat file_stat;
15611
15612 if (stat (filename, &file_stat) == -1)
15613 {
15614 log_error ("ERROR: %s: %s", filename, strerror (errno));
15615
15616 return (-1);
15617 }
15618
15619 uint is_dir = S_ISDIR (file_stat.st_mode);
15620
15621 if (is_dir == 0)
15622 {
15623 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15624
15625 dictcnt++;
15626
15627 dictfiles[dictcnt - 1] = filename;
15628 }
15629 else
15630 {
15631 // do not allow --keyspace w/ a directory
15632
15633 if (keyspace == 1)
15634 {
15635 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15636
15637 return (-1);
15638 }
15639
15640 char **dictionary_files = NULL;
15641
15642 dictionary_files = scan_directory (filename);
15643
15644 if (dictionary_files != NULL)
15645 {
15646 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15647
15648 for (int d = 0; dictionary_files[d] != NULL; d++)
15649 {
15650 char *l1_filename = dictionary_files[d];
15651
15652 struct stat l1_stat;
15653
15654 if (stat (l1_filename, &l1_stat) == -1)
15655 {
15656 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15657
15658 return (-1);
15659 }
15660
15661 if (S_ISREG (l1_stat.st_mode))
15662 {
15663 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15664
15665 dictcnt++;
15666
15667 dictfiles[dictcnt - 1] = strdup (l1_filename);
15668 }
15669 }
15670 }
15671
15672 local_free (dictionary_files);
15673 }
15674 }
15675
15676 if (dictcnt < 1)
15677 {
15678 log_error ("ERROR: No usable dictionary file found.");
15679
15680 return (-1);
15681 }
15682
15683 if (increment)
15684 {
15685 maskcnt = 0;
15686
15687 uint mask_min = increment_min; // we can't reject smaller masks here
15688 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15689
15690 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15691 {
15692 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15693
15694 if (cur_mask == NULL) break;
15695
15696 masks[maskcnt] = cur_mask;
15697
15698 maskcnt++;
15699
15700 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15701 }
15702 }
15703 }
15704
15705 data.pw_min = pw_min;
15706 data.pw_max = pw_max;
15707
15708 /**
15709 * weak hash check
15710 */
15711
15712 if (weak_hash_threshold >= salts_cnt)
15713 {
15714 hc_device_param_t *device_param = NULL;
15715
15716 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15717 {
15718 device_param = &data.devices_param[device_id];
15719
15720 if (device_param->skipped) continue;
15721
15722 break;
15723 }
15724
15725 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15726
15727 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15728 {
15729 weak_hash_check (device_param, salt_pos);
15730 }
15731 }
15732
15733 // Display hack, guarantee that there is at least one \r before real start
15734
15735 if (data.quiet == 0) log_info_nn ("");
15736
15737 /**
15738 * status and monitor threads
15739 */
15740
15741 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15742
15743 hc_thread_t i_thread = 0;
15744
15745 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15746 {
15747 hc_thread_create (i_thread, thread_keypress, &benchmark);
15748 }
15749
15750 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15751
15752 uint ni_threads_cnt = 0;
15753
15754 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15755
15756 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15757
15758 ni_threads_cnt++;
15759
15760 /**
15761 * Outfile remove
15762 */
15763
15764 if (keyspace == 0)
15765 {
15766 if (outfile_check_timer != 0)
15767 {
15768 if (data.outfile_check_directory != NULL)
15769 {
15770 if ((hash_mode != 5200) &&
15771 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15772 (hash_mode != 9000))
15773 {
15774 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15775
15776 ni_threads_cnt++;
15777 }
15778 else
15779 {
15780 outfile_check_timer = 0;
15781 }
15782 }
15783 else
15784 {
15785 outfile_check_timer = 0;
15786 }
15787 }
15788 }
15789
15790 /**
15791 * Inform the user if we got some hashes remove because of the pot file remove feature
15792 */
15793
15794 if (data.quiet == 0)
15795 {
15796 if (potfile_remove_cracks > 0)
15797 {
15798 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15799 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15800 }
15801 }
15802
15803 data.outfile_check_timer = outfile_check_timer;
15804
15805 /**
15806 * main loop
15807 */
15808
15809 char **induction_dictionaries = NULL;
15810
15811 int induction_dictionaries_cnt = 0;
15812
15813 hcstat_table_t *root_table_buf = NULL;
15814 hcstat_table_t *markov_table_buf = NULL;
15815
15816 uint initial_restore_done = 0;
15817
15818 data.maskcnt = maskcnt;
15819
15820 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15821 {
15822 if (data.devices_status == STATUS_CRACKED) break;
15823
15824 data.devices_status = STATUS_INIT;
15825
15826 if (maskpos > rd->maskpos)
15827 {
15828 rd->dictpos = 0;
15829 }
15830
15831 rd->maskpos = maskpos;
15832 data.maskpos = maskpos;
15833
15834 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15835 {
15836 char *mask = masks[maskpos];
15837
15838 if (mask_from_file == 1)
15839 {
15840 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15841
15842 char *str_ptr;
15843 uint str_pos;
15844
15845 uint mask_offset = 0;
15846
15847 uint separator_cnt;
15848
15849 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15850 {
15851 str_ptr = strstr (mask + mask_offset, ",");
15852
15853 if (str_ptr == NULL) break;
15854
15855 str_pos = str_ptr - mask;
15856
15857 // escaped separator, i.e. "\,"
15858
15859 if (str_pos > 0)
15860 {
15861 if (mask[str_pos - 1] == '\\')
15862 {
15863 separator_cnt --;
15864
15865 mask_offset = str_pos + 1;
15866
15867 continue;
15868 }
15869 }
15870
15871 // reset the offset
15872
15873 mask_offset = 0;
15874
15875 mask[str_pos] = '\0';
15876
15877 switch (separator_cnt)
15878 {
15879 case 0:
15880 mp_reset_usr (mp_usr, 0);
15881
15882 custom_charset_1 = mask;
15883 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15884 break;
15885
15886 case 1:
15887 mp_reset_usr (mp_usr, 1);
15888
15889 custom_charset_2 = mask;
15890 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15891 break;
15892
15893 case 2:
15894 mp_reset_usr (mp_usr, 2);
15895
15896 custom_charset_3 = mask;
15897 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15898 break;
15899
15900 case 3:
15901 mp_reset_usr (mp_usr, 3);
15902
15903 custom_charset_4 = mask;
15904 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15905 break;
15906 }
15907
15908 mask = mask + str_pos + 1;
15909 }
15910 }
15911
15912 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15913 {
15914 if (maskpos > 0)
15915 {
15916 local_free (css_buf);
15917 local_free (data.root_css_buf);
15918 local_free (data.markov_css_buf);
15919
15920 local_free (masks[maskpos - 1]);
15921 }
15922
15923 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15924
15925 data.mask = mask;
15926 data.css_cnt = css_cnt;
15927 data.css_buf = css_buf;
15928
15929 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15930
15931 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15932
15933 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15934 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15935
15936 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15937
15938 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15939
15940 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15941 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15942
15943 data.root_css_buf = root_css_buf;
15944 data.markov_css_buf = markov_css_buf;
15945
15946 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15947
15948 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15949
15950 local_free (root_table_buf);
15951 local_free (markov_table_buf);
15952
15953 // args
15954
15955 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15956 {
15957 hc_device_param_t *device_param = &data.devices_param[device_id];
15958
15959 if (device_param->skipped) continue;
15960
15961 device_param->kernel_params_mp[0] = &device_param->d_combs;
15962 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15963 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15964
15965 device_param->kernel_params_mp_buf64[3] = 0;
15966 device_param->kernel_params_mp_buf32[4] = css_cnt;
15967 device_param->kernel_params_mp_buf32[5] = 0;
15968 device_param->kernel_params_mp_buf32[6] = 0;
15969 device_param->kernel_params_mp_buf32[7] = 0;
15970
15971 if (attack_mode == ATTACK_MODE_HYBRID1)
15972 {
15973 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15974 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15975 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15976 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15977 }
15978 else if (attack_mode == ATTACK_MODE_HYBRID2)
15979 {
15980 device_param->kernel_params_mp_buf32[5] = 0;
15981 device_param->kernel_params_mp_buf32[6] = 0;
15982 device_param->kernel_params_mp_buf32[7] = 0;
15983 }
15984
15985 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]);
15986 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]);
15987 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]);
15988
15989 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);
15990 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);
15991 }
15992 }
15993 else if (attack_mode == ATTACK_MODE_BF)
15994 {
15995 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15996
15997 if (increment)
15998 {
15999 for (uint i = 0; i < dictcnt; i++)
16000 {
16001 local_free (dictfiles[i]);
16002 }
16003
16004 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16005 {
16006 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16007
16008 if (l1_filename == NULL) break;
16009
16010 dictcnt++;
16011
16012 dictfiles[dictcnt - 1] = l1_filename;
16013 }
16014 }
16015 else
16016 {
16017 dictcnt++;
16018
16019 dictfiles[dictcnt - 1] = mask;
16020 }
16021
16022 if (dictcnt == 0)
16023 {
16024 log_error ("ERROR: Mask is too small");
16025
16026 return (-1);
16027 }
16028 }
16029 }
16030
16031 free (induction_dictionaries);
16032
16033 // induction_dictionaries_cnt = 0; // implied
16034
16035 if (attack_mode != ATTACK_MODE_BF)
16036 {
16037 if (keyspace == 0)
16038 {
16039 induction_dictionaries = scan_directory (induction_directory);
16040
16041 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16042 }
16043 }
16044
16045 if (induction_dictionaries_cnt)
16046 {
16047 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16048 }
16049
16050 /**
16051 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16052 */
16053 if (keyspace == 1)
16054 {
16055 if ((maskcnt > 1) || (dictcnt > 1))
16056 {
16057 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16058
16059 return (-1);
16060 }
16061 }
16062
16063 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16064 {
16065 char *subid = logfile_generate_subid ();
16066
16067 data.subid = subid;
16068
16069 logfile_sub_msg ("START");
16070
16071 data.devices_status = STATUS_INIT;
16072
16073 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16074 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16075 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16076
16077 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16078
16079 data.cpt_pos = 0;
16080
16081 data.cpt_start = time (NULL);
16082
16083 data.cpt_total = 0;
16084
16085 if (data.restore == 0)
16086 {
16087 rd->words_cur = skip;
16088
16089 skip = 0;
16090
16091 data.skip = 0;
16092 }
16093
16094 data.ms_paused = 0;
16095
16096 data.words_cur = rd->words_cur;
16097
16098 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16099 {
16100 hc_device_param_t *device_param = &data.devices_param[device_id];
16101
16102 if (device_param->skipped) continue;
16103
16104 device_param->speed_pos = 0;
16105
16106 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16107 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16108
16109 device_param->exec_pos = 0;
16110
16111 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16112
16113 device_param->kernel_power = device_param->kernel_power_user;
16114
16115 device_param->outerloop_pos = 0;
16116 device_param->outerloop_left = 0;
16117 device_param->innerloop_pos = 0;
16118 device_param->innerloop_left = 0;
16119
16120 // some more resets:
16121
16122 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16123
16124 device_param->pws_cnt = 0;
16125
16126 device_param->words_off = 0;
16127 device_param->words_done = 0;
16128 }
16129
16130 data.kernel_power_div = 0;
16131
16132 // figure out some workload
16133
16134 if (attack_mode == ATTACK_MODE_STRAIGHT)
16135 {
16136 if (data.wordlist_mode == WL_MODE_FILE)
16137 {
16138 char *dictfile = NULL;
16139
16140 if (induction_dictionaries_cnt)
16141 {
16142 dictfile = induction_dictionaries[0];
16143 }
16144 else
16145 {
16146 dictfile = dictfiles[dictpos];
16147 }
16148
16149 data.dictfile = dictfile;
16150
16151 logfile_sub_string (dictfile);
16152
16153 for (uint i = 0; i < rp_files_cnt; i++)
16154 {
16155 logfile_sub_var_string ("rulefile", rp_files[i]);
16156 }
16157
16158 FILE *fd2 = fopen (dictfile, "rb");
16159
16160 if (fd2 == NULL)
16161 {
16162 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16163
16164 return (-1);
16165 }
16166
16167 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16168
16169 fclose (fd2);
16170
16171 if (data.words_cnt == 0)
16172 {
16173 if (data.devices_status == STATUS_CRACKED) break;
16174 if (data.devices_status == STATUS_ABORTED) break;
16175
16176 dictpos++;
16177
16178 continue;
16179 }
16180 }
16181 }
16182 else if (attack_mode == ATTACK_MODE_COMBI)
16183 {
16184 char *dictfile = data.dictfile;
16185 char *dictfile2 = data.dictfile2;
16186
16187 logfile_sub_string (dictfile);
16188 logfile_sub_string (dictfile2);
16189
16190 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16191 {
16192 FILE *fd2 = fopen (dictfile, "rb");
16193
16194 if (fd2 == NULL)
16195 {
16196 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16197
16198 return (-1);
16199 }
16200
16201 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16202
16203 fclose (fd2);
16204 }
16205 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16206 {
16207 FILE *fd2 = fopen (dictfile2, "rb");
16208
16209 if (fd2 == NULL)
16210 {
16211 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16212
16213 return (-1);
16214 }
16215
16216 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16217
16218 fclose (fd2);
16219 }
16220
16221 if (data.words_cnt == 0)
16222 {
16223 if (data.devices_status == STATUS_CRACKED) break;
16224 if (data.devices_status == STATUS_ABORTED) break;
16225
16226 dictpos++;
16227
16228 continue;
16229 }
16230 }
16231 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16232 {
16233 char *dictfile = NULL;
16234
16235 if (induction_dictionaries_cnt)
16236 {
16237 dictfile = induction_dictionaries[0];
16238 }
16239 else
16240 {
16241 dictfile = dictfiles[dictpos];
16242 }
16243
16244 data.dictfile = dictfile;
16245
16246 char *mask = data.mask;
16247
16248 logfile_sub_string (dictfile);
16249 logfile_sub_string (mask);
16250
16251 FILE *fd2 = fopen (dictfile, "rb");
16252
16253 if (fd2 == NULL)
16254 {
16255 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16256
16257 return (-1);
16258 }
16259
16260 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16261
16262 fclose (fd2);
16263
16264 if (data.words_cnt == 0)
16265 {
16266 if (data.devices_status == STATUS_CRACKED) break;
16267 if (data.devices_status == STATUS_ABORTED) break;
16268
16269 dictpos++;
16270
16271 continue;
16272 }
16273 }
16274 else if (attack_mode == ATTACK_MODE_BF)
16275 {
16276 local_free (css_buf);
16277 local_free (data.root_css_buf);
16278 local_free (data.markov_css_buf);
16279
16280 char *mask = dictfiles[dictpos];
16281
16282 logfile_sub_string (mask);
16283
16284 // base
16285
16286 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16287
16288 if (opts_type & OPTS_TYPE_PT_UNICODE)
16289 {
16290 uint css_cnt_unicode = css_cnt * 2;
16291
16292 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16293
16294 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16295 {
16296 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16297
16298 css_buf_unicode[j + 1].cs_buf[0] = 0;
16299 css_buf_unicode[j + 1].cs_len = 1;
16300 }
16301
16302 free (css_buf);
16303
16304 css_buf = css_buf_unicode;
16305 css_cnt = css_cnt_unicode;
16306 }
16307
16308 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16309
16310 uint mask_min = pw_min;
16311 uint mask_max = pw_max;
16312
16313 if (opts_type & OPTS_TYPE_PT_UNICODE)
16314 {
16315 mask_min *= 2;
16316 mask_max *= 2;
16317 }
16318
16319 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16320 {
16321 if (css_cnt < mask_min)
16322 {
16323 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16324 }
16325
16326 if (css_cnt > mask_max)
16327 {
16328 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16329 }
16330
16331 // skip to next mask
16332
16333 dictpos++;
16334
16335 rd->dictpos = dictpos;
16336
16337 logfile_sub_msg ("STOP");
16338
16339 continue;
16340 }
16341
16342 uint save_css_cnt = css_cnt;
16343
16344 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16345 {
16346 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16347 {
16348 uint salt_len = (uint) data.salts_buf[0].salt_len;
16349 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16350
16351 uint css_cnt_salt = css_cnt + salt_len;
16352
16353 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16354
16355 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16356
16357 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16358 {
16359 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16360 css_buf_salt[j].cs_len = 1;
16361 }
16362
16363 free (css_buf);
16364
16365 css_buf = css_buf_salt;
16366 css_cnt = css_cnt_salt;
16367 }
16368 }
16369
16370 data.mask = mask;
16371 data.css_cnt = css_cnt;
16372 data.css_buf = css_buf;
16373
16374 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16375
16376 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16377
16378 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16379
16380 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16381 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16382
16383 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16384
16385 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16386
16387 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16388 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16389
16390 data.root_css_buf = root_css_buf;
16391 data.markov_css_buf = markov_css_buf;
16392
16393 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16394
16395 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16396
16397 local_free (root_table_buf);
16398 local_free (markov_table_buf);
16399
16400 // copy + args
16401
16402 uint css_cnt_l = css_cnt;
16403 uint css_cnt_r;
16404
16405 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16406 {
16407 if (save_css_cnt < 6)
16408 {
16409 css_cnt_r = 1;
16410 }
16411 else if (save_css_cnt == 6)
16412 {
16413 css_cnt_r = 2;
16414 }
16415 else
16416 {
16417 if (opts_type & OPTS_TYPE_PT_UNICODE)
16418 {
16419 if (save_css_cnt == 8 || save_css_cnt == 10)
16420 {
16421 css_cnt_r = 2;
16422 }
16423 else
16424 {
16425 css_cnt_r = 4;
16426 }
16427 }
16428 else
16429 {
16430 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16431 {
16432 css_cnt_r = 3;
16433 }
16434 else
16435 {
16436 css_cnt_r = 4;
16437 }
16438 }
16439 }
16440 }
16441 else
16442 {
16443 css_cnt_r = 1;
16444
16445 /* unfinished code?
16446 int sum = css_buf[css_cnt_r - 1].cs_len;
16447
16448 for (uint i = 1; i < 4 && i < css_cnt; i++)
16449 {
16450 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16451
16452 css_cnt_r++;
16453
16454 sum *= css_buf[css_cnt_r - 1].cs_len;
16455 }
16456 */
16457 }
16458
16459 css_cnt_l -= css_cnt_r;
16460
16461 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16462
16463 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16464 {
16465 hc_device_param_t *device_param = &data.devices_param[device_id];
16466
16467 if (device_param->skipped) continue;
16468
16469 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16470 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16471 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16472
16473 device_param->kernel_params_mp_l_buf64[3] = 0;
16474 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16475 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16476 device_param->kernel_params_mp_l_buf32[6] = 0;
16477 device_param->kernel_params_mp_l_buf32[7] = 0;
16478 device_param->kernel_params_mp_l_buf32[8] = 0;
16479
16480 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16481 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16482 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16483 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16484
16485 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16486 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16487 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16488
16489 device_param->kernel_params_mp_r_buf64[3] = 0;
16490 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16491 device_param->kernel_params_mp_r_buf32[5] = 0;
16492 device_param->kernel_params_mp_r_buf32[6] = 0;
16493 device_param->kernel_params_mp_r_buf32[7] = 0;
16494
16495 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]);
16496 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]);
16497 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]);
16498
16499 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]);
16500 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]);
16501 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]);
16502
16503 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);
16504 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);
16505 }
16506 }
16507
16508 u64 words_base = data.words_cnt;
16509
16510 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16511 {
16512 if (data.kernel_rules_cnt)
16513 {
16514 words_base /= data.kernel_rules_cnt;
16515 }
16516 }
16517 else if (data.attack_kern == ATTACK_KERN_COMBI)
16518 {
16519 if (data.combs_cnt)
16520 {
16521 words_base /= data.combs_cnt;
16522 }
16523 }
16524 else if (data.attack_kern == ATTACK_KERN_BF)
16525 {
16526 if (data.bfs_cnt)
16527 {
16528 words_base /= data.bfs_cnt;
16529 }
16530 }
16531
16532 data.words_base = words_base;
16533
16534 if (keyspace == 1)
16535 {
16536 log_info ("%llu", (unsigned long long int) words_base);
16537
16538 return (0);
16539 }
16540
16541 if (data.words_cur > data.words_base)
16542 {
16543 log_error ("ERROR: restore value greater keyspace");
16544
16545 return (-1);
16546 }
16547
16548 if (data.words_cur)
16549 {
16550 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16551 {
16552 for (uint i = 0; i < data.salts_cnt; i++)
16553 {
16554 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16555 }
16556 }
16557 else if (data.attack_kern == ATTACK_KERN_COMBI)
16558 {
16559 for (uint i = 0; i < data.salts_cnt; i++)
16560 {
16561 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16562 }
16563 }
16564 else if (data.attack_kern == ATTACK_KERN_BF)
16565 {
16566 for (uint i = 0; i < data.salts_cnt; i++)
16567 {
16568 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16569 }
16570 }
16571 }
16572
16573 /*
16574 * Inform user about possible slow speeds
16575 */
16576
16577 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16578 {
16579 if (data.words_base < kernel_power_all)
16580 {
16581 if (quiet == 0)
16582 {
16583 log_info ("");
16584 log_info ("ATTENTION!");
16585 log_info (" The wordlist or mask you are using is too small.");
16586 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16587 log_info (" The cracking speed will drop.");
16588 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16589 log_info ("");
16590 }
16591 }
16592 }
16593
16594 /*
16595 * Update loopback file
16596 */
16597
16598 if (loopback == 1)
16599 {
16600 time_t now;
16601
16602 time (&now);
16603
16604 uint random_num = get_random_num (0, 9999);
16605
16606 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16607
16608 data.loopback_file = loopback_file;
16609 }
16610
16611 /*
16612 * Update dictionary statistic
16613 */
16614
16615 if (keyspace == 0)
16616 {
16617 dictstat_fp = fopen (dictstat, "wb");
16618
16619 if (dictstat_fp)
16620 {
16621 lock_file (dictstat_fp);
16622
16623 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16624
16625 fclose (dictstat_fp);
16626 }
16627 }
16628
16629 data.devices_status = STATUS_RUNNING;
16630
16631 if (initial_restore_done == 0)
16632 {
16633 if (data.restore_disable == 0) cycle_restore ();
16634
16635 initial_restore_done = 1;
16636 }
16637
16638 hc_timer_set (&data.timer_running);
16639
16640 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16641 {
16642 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16643 {
16644 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16645 if (quiet == 0) fflush (stdout);
16646 }
16647 }
16648 else if (wordlist_mode == WL_MODE_STDIN)
16649 {
16650 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16651 if (data.quiet == 0) log_info ("");
16652 }
16653
16654 time_t runtime_start;
16655
16656 time (&runtime_start);
16657
16658 data.runtime_start = runtime_start;
16659
16660 /**
16661 * create cracker threads
16662 */
16663
16664 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16665
16666 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16667 {
16668 hc_device_param_t *device_param = &devices_param[device_id];
16669
16670 if (wordlist_mode == WL_MODE_STDIN)
16671 {
16672 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16673 }
16674 else
16675 {
16676 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16677 }
16678 }
16679
16680 // wait for crack threads to exit
16681
16682 hc_thread_wait (data.devices_cnt, c_threads);
16683
16684 local_free (c_threads);
16685
16686 data.restore = 0;
16687
16688 // finalize task
16689
16690 logfile_sub_var_uint ("status-after-work", data.devices_status);
16691
16692 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16693
16694 if (data.devices_status == STATUS_CRACKED) break;
16695 if (data.devices_status == STATUS_ABORTED) break;
16696
16697 if (data.devices_status == STATUS_BYPASS)
16698 {
16699 data.devices_status = STATUS_RUNNING;
16700 }
16701
16702 if (induction_dictionaries_cnt)
16703 {
16704 unlink (induction_dictionaries[0]);
16705 }
16706
16707 free (induction_dictionaries);
16708
16709 if (attack_mode != ATTACK_MODE_BF)
16710 {
16711 induction_dictionaries = scan_directory (induction_directory);
16712
16713 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16714 }
16715
16716 if (benchmark == 0)
16717 {
16718 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16719 {
16720 if (quiet == 0) clear_prompt ();
16721
16722 if (quiet == 0) log_info ("");
16723
16724 if (status == 1)
16725 {
16726 status_display ();
16727 }
16728 else
16729 {
16730 if (quiet == 0) status_display ();
16731 }
16732
16733 if (quiet == 0) log_info ("");
16734 }
16735 }
16736
16737 if (attack_mode == ATTACK_MODE_BF)
16738 {
16739 dictpos++;
16740
16741 rd->dictpos = dictpos;
16742 }
16743 else
16744 {
16745 if (induction_dictionaries_cnt)
16746 {
16747 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16748 }
16749 else
16750 {
16751 dictpos++;
16752
16753 rd->dictpos = dictpos;
16754 }
16755 }
16756
16757 time_t runtime_stop;
16758
16759 time (&runtime_stop);
16760
16761 data.runtime_stop = runtime_stop;
16762
16763 logfile_sub_uint (runtime_start);
16764 logfile_sub_uint (runtime_stop);
16765
16766 logfile_sub_msg ("STOP");
16767
16768 global_free (subid);
16769 }
16770
16771 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16772
16773 if (data.devices_status == STATUS_CRACKED) break;
16774 if (data.devices_status == STATUS_ABORTED) break;
16775 if (data.devices_status == STATUS_QUIT) break;
16776
16777 if (data.devices_status == STATUS_BYPASS)
16778 {
16779 data.devices_status = STATUS_RUNNING;
16780 }
16781 }
16782
16783 // 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
16784
16785 if (attack_mode == ATTACK_MODE_STRAIGHT)
16786 {
16787 if (data.wordlist_mode == WL_MODE_FILE)
16788 {
16789 if (data.dictfile == NULL)
16790 {
16791 if (dictfiles != NULL)
16792 {
16793 data.dictfile = dictfiles[0];
16794
16795 hc_timer_set (&data.timer_running);
16796 }
16797 }
16798 }
16799 }
16800 // NOTE: combi is okay because it is already set beforehand
16801 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16802 {
16803 if (data.dictfile == NULL)
16804 {
16805 if (dictfiles != NULL)
16806 {
16807 hc_timer_set (&data.timer_running);
16808
16809 data.dictfile = dictfiles[0];
16810 }
16811 }
16812 }
16813 else if (attack_mode == ATTACK_MODE_BF)
16814 {
16815 if (data.mask == NULL)
16816 {
16817 hc_timer_set (&data.timer_running);
16818
16819 data.mask = masks[0];
16820 }
16821 }
16822
16823 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16824 {
16825 data.devices_status = STATUS_EXHAUSTED;
16826 }
16827
16828 // if cracked / aborted remove last induction dictionary
16829
16830 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16831 {
16832 struct stat induct_stat;
16833
16834 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16835 {
16836 unlink (induction_dictionaries[file_pos]);
16837 }
16838 }
16839
16840 // wait for non-interactive threads
16841
16842 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16843 {
16844 hc_thread_wait (1, &ni_threads[thread_idx]);
16845 }
16846
16847 local_free (ni_threads);
16848
16849 // wait for interactive threads
16850
16851 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16852 {
16853 hc_thread_wait (1, &i_thread);
16854 }
16855
16856 // we dont need restore file anymore
16857 if (data.restore_disable == 0)
16858 {
16859 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16860 {
16861 unlink (eff_restore_file);
16862 unlink (new_restore_file);
16863 }
16864 else
16865 {
16866 cycle_restore ();
16867 }
16868 }
16869
16870 // finally save left hashes
16871
16872 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16873 {
16874 save_hash ();
16875 }
16876
16877 /**
16878 * Clean up
16879 */
16880
16881 if (benchmark == 1)
16882 {
16883 status_benchmark ();
16884
16885 log_info ("");
16886 }
16887 else
16888 {
16889 if (quiet == 0) clear_prompt ();
16890
16891 if (quiet == 0) log_info ("");
16892
16893 if (status == 1)
16894 {
16895 status_display ();
16896 }
16897 else
16898 {
16899 if (quiet == 0) status_display ();
16900 }
16901
16902 if (quiet == 0) log_info ("");
16903 }
16904
16905 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16906 {
16907 hc_device_param_t *device_param = &data.devices_param[device_id];
16908
16909 if (device_param->skipped) continue;
16910
16911 local_free (device_param->result);
16912
16913 local_free (device_param->combs_buf);
16914
16915 local_free (device_param->hooks_buf);
16916
16917 local_free (device_param->device_name);
16918
16919 local_free (device_param->device_name_chksum);
16920
16921 local_free (device_param->device_version);
16922
16923 local_free (device_param->driver_version);
16924
16925 if (device_param->pws_buf) myfree (device_param->pws_buf);
16926 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16927 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16928 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16929 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16930 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16931 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16932 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16933 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16934 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16935 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16936 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16937 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16938 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16939 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16940 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16941 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16942 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16943 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16944 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16945 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16946 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16947 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16948 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16949 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16950 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16951 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16952 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16953 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16954
16955 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16956 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16957 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16958 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16959 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16960 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16961 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16962 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16963 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16964 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16965
16966 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16967 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16968 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16969
16970 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16971 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16972 }
16973
16974 // reset default fan speed
16975
16976 #ifdef HAVE_HWMON
16977 if (gpu_temp_disable == 0)
16978 {
16979 #ifdef HAVE_ADL
16980 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16981 {
16982 hc_thread_mutex_lock (mux_adl);
16983
16984 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16985 {
16986 hc_device_param_t *device_param = &data.devices_param[device_id];
16987
16988 if (device_param->skipped) continue;
16989
16990 if (data.hm_device[device_id].fan_supported == 1)
16991 {
16992 int fanspeed = temp_retain_fanspeed_value[device_id];
16993
16994 if (fanspeed == -1) continue;
16995
16996 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16997
16998 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16999 }
17000 }
17001
17002 hc_thread_mutex_unlock (mux_adl);
17003 }
17004 #endif // HAVE_ADL
17005 }
17006
17007 #ifdef HAVE_ADL
17008 // reset power tuning
17009
17010 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17011 {
17012 hc_thread_mutex_lock (mux_adl);
17013
17014 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17015 {
17016 hc_device_param_t *device_param = &data.devices_param[device_id];
17017
17018 if (device_param->skipped) continue;
17019
17020 if (data.hm_device[device_id].od_version == 6)
17021 {
17022 // check powertune capabilities first, if not available then skip device
17023
17024 int powertune_supported = 0;
17025
17026 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17027 {
17028 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17029
17030 return (-1);
17031 }
17032
17033 if (powertune_supported != 0)
17034 {
17035 // powercontrol settings
17036
17037 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)
17038 {
17039 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17040
17041 return (-1);
17042 }
17043
17044 // clocks
17045
17046 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17047
17048 performance_state->iNumberOfPerformanceLevels = 2;
17049
17050 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17051 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17052 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17053 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17054
17055 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)
17056 {
17057 log_info ("ERROR: Failed to restore ADL performance state");
17058
17059 return (-1);
17060 }
17061
17062 local_free (performance_state);
17063 }
17064 }
17065 }
17066
17067 hc_thread_mutex_unlock (mux_adl);
17068 }
17069 #endif // HAVE_ADL
17070
17071 if (gpu_temp_disable == 0)
17072 {
17073 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17074 if (data.hm_nv)
17075 {
17076 #if defined(LINUX) && defined(HAVE_NVML)
17077
17078 hm_NVML_nvmlShutdown (data.hm_nv);
17079
17080 nvml_close (data.hm_nv);
17081
17082 #elif defined(WIN) && (HAVE_NVAPI)
17083
17084 hm_NvAPI_Unload (data.hm_nv);
17085
17086 nvapi_close (data.hm_nv);
17087
17088 #endif
17089
17090 data.hm_nv = NULL;
17091 }
17092 #endif
17093
17094 #ifdef HAVE_ADL
17095 if (data.hm_amd)
17096 {
17097 hm_ADL_Main_Control_Destroy (data.hm_amd);
17098
17099 adl_close (data.hm_amd);
17100 data.hm_amd = NULL;
17101 }
17102 #endif
17103 }
17104 #endif // HAVE_HWMON
17105
17106 // free memory
17107
17108 local_free (masks);
17109
17110 local_free (dictstat_base);
17111
17112 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17113 {
17114 pot_t *pot_ptr = &pot[pot_pos];
17115
17116 hash_t *hash = &pot_ptr->hash;
17117
17118 local_free (hash->digest);
17119
17120 if (isSalted)
17121 {
17122 local_free (hash->salt);
17123 }
17124 }
17125
17126 local_free (pot);
17127
17128 local_free (all_kernel_rules_cnt);
17129 local_free (all_kernel_rules_buf);
17130
17131 local_free (wl_data->buf);
17132 local_free (wl_data);
17133
17134 local_free (bitmap_s1_a);
17135 local_free (bitmap_s1_b);
17136 local_free (bitmap_s1_c);
17137 local_free (bitmap_s1_d);
17138 local_free (bitmap_s2_a);
17139 local_free (bitmap_s2_b);
17140 local_free (bitmap_s2_c);
17141 local_free (bitmap_s2_d);
17142
17143 #ifdef HAVE_HWMON
17144 local_free (temp_retain_fanspeed_value);
17145 #ifdef HAVE_ADL
17146 local_free (od_clock_mem_status);
17147 local_free (od_power_control_status);
17148 #endif // ADL
17149 #endif
17150
17151 global_free (devices_param);
17152
17153 global_free (kernel_rules_buf);
17154
17155 global_free (root_css_buf);
17156 global_free (markov_css_buf);
17157
17158 global_free (digests_buf);
17159 global_free (digests_shown);
17160 global_free (digests_shown_tmp);
17161
17162 global_free (salts_buf);
17163 global_free (salts_shown);
17164
17165 global_free (esalts_buf);
17166
17167 global_free (words_progress_done);
17168 global_free (words_progress_rejected);
17169 global_free (words_progress_restored);
17170
17171 if (pot_fp) fclose (pot_fp);
17172
17173 if (data.devices_status == STATUS_QUIT) break;
17174 }
17175
17176 // destroy others mutex
17177
17178 hc_thread_mutex_delete (mux_dispatcher);
17179 hc_thread_mutex_delete (mux_counter);
17180 hc_thread_mutex_delete (mux_display);
17181 hc_thread_mutex_delete (mux_adl);
17182
17183 // free memory
17184
17185 local_free (eff_restore_file);
17186 local_free (new_restore_file);
17187
17188 local_free (rd);
17189
17190 // tuning db
17191
17192 tuning_db_destroy (tuning_db);
17193
17194 // loopback
17195
17196 local_free (loopback_file);
17197
17198 if (loopback == 1) unlink (loopback_file);
17199
17200 // induction directory
17201
17202 if (induction_dir == NULL)
17203 {
17204 if (attack_mode != ATTACK_MODE_BF)
17205 {
17206 if (rmdir (induction_directory) == -1)
17207 {
17208 if (errno == ENOENT)
17209 {
17210 // good, we can ignore
17211 }
17212 else if (errno == ENOTEMPTY)
17213 {
17214 // good, we can ignore
17215 }
17216 else
17217 {
17218 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17219
17220 return (-1);
17221 }
17222 }
17223
17224 local_free (induction_directory);
17225 }
17226 }
17227
17228 // outfile-check directory
17229
17230 if (outfile_check_dir == NULL)
17231 {
17232 if (rmdir (outfile_check_directory) == -1)
17233 {
17234 if (errno == ENOENT)
17235 {
17236 // good, we can ignore
17237 }
17238 else if (errno == ENOTEMPTY)
17239 {
17240 // good, we can ignore
17241 }
17242 else
17243 {
17244 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17245
17246 return (-1);
17247 }
17248 }
17249
17250 local_free (outfile_check_directory);
17251 }
17252
17253 time_t proc_stop;
17254
17255 time (&proc_stop);
17256
17257 logfile_top_uint (proc_start);
17258 logfile_top_uint (proc_stop);
17259
17260 logfile_top_msg ("STOP");
17261
17262 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17263 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17264
17265 if (data.ocl) ocl_close (data.ocl);
17266
17267 if (data.devices_status == STATUS_ABORTED) return 2;
17268 if (data.devices_status == STATUS_QUIT) return 2;
17269 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17270 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17271 if (data.devices_status == STATUS_CRACKED) return 0;
17272
17273 return -1;
17274 }
Hashcat additions to support pwdhash