projects / hashcat.git / blob
? search:


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