projects / hashcat.git / blob
? search:


82f0c4001856ee84d6d44bbf7e83bd0db78829b4
[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_MAX 256
88 #define KERNEL_THREADS_MAX_CPU 16
89 #define POWERTUNE_ENABLE 0
90 #define LOGFILE_DISABLE 0
91 #define SCRYPT_TMTO 0
92 #define OPENCL_VECTOR_WIDTH 0
93
94 #define WL_MODE_STDIN 1
95 #define WL_MODE_FILE 2
96 #define WL_MODE_MASK 3
97
98 #define HL_MODE_FILE 4
99 #define HL_MODE_ARG 5
100
101 #define HLFMTS_CNT 11
102 #define HLFMT_HASHCAT 0
103 #define HLFMT_PWDUMP 1
104 #define HLFMT_PASSWD 2
105 #define HLFMT_SHADOW 3
106 #define HLFMT_DCC 4
107 #define HLFMT_DCC2 5
108 #define HLFMT_NETNTLM1 7
109 #define HLFMT_NETNTLM2 8
110 #define HLFMT_NSLDAP 9
111 #define HLFMT_NSLDAPS 10
112
113 #define HLFMT_TEXT_HASHCAT "native hashcat"
114 #define HLFMT_TEXT_PWDUMP "pwdump"
115 #define HLFMT_TEXT_PASSWD "passwd"
116 #define HLFMT_TEXT_SHADOW "shadow"
117 #define HLFMT_TEXT_DCC "DCC"
118 #define HLFMT_TEXT_DCC2 "DCC 2"
119 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
120 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
121 #define HLFMT_TEXT_NSLDAP "nsldap"
122 #define HLFMT_TEXT_NSLDAPS "nsldaps"
123
124 #define ATTACK_MODE_STRAIGHT 0
125 #define ATTACK_MODE_COMBI 1
126 #define ATTACK_MODE_TOGGLE 2
127 #define ATTACK_MODE_BF 3
128 #define ATTACK_MODE_PERM 4
129 #define ATTACK_MODE_TABLE 5
130 #define ATTACK_MODE_HYBRID1 6
131 #define ATTACK_MODE_HYBRID2 7
132 #define ATTACK_MODE_NONE 100
133
134 #define ATTACK_KERN_STRAIGHT 0
135 #define ATTACK_KERN_COMBI 1
136 #define ATTACK_KERN_BF 3
137 #define ATTACK_KERN_NONE 100
138
139 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
140 #define ATTACK_EXEC_INSIDE_KERNEL 11
141
142 #define COMBINATOR_MODE_BASE_LEFT 10001
143 #define COMBINATOR_MODE_BASE_RIGHT 10002
144
145 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
146 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
147
148 #define MAX_CUT_TRIES 4
149
150 #define MAX_DICTSTAT 10000
151
152 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 136
153
154 #define global_free(attr) \
155 { \
156 myfree ((void *) data.attr); \
157 \
158 data.attr = NULL; \
159 }
160
161 #define local_free(attr) \
162 { \
163 myfree ((void *) attr); \
164 \
165 attr = NULL; \
166 }
167
168 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
169 {
170 900,
171 0,
172 5100,
173 100,
174 1400,
175 10800,
176 1700,
177 5000,
178 10100,
179 6000,
180 6100,
181 6900,
182 11700,
183 11800,
184 400,
185 8900,
186 11900,
187 12000,
188 10900,
189 12100,
190 23,
191 2500,
192 5300,
193 5400,
194 5500,
195 5600,
196 7300,
197 7500,
198 13100,
199 8300,
200 11100,
201 11200,
202 11400,
203 121,
204 2611,
205 2711,
206 2811,
207 8400,
208 11,
209 2612,
210 7900,
211 21,
212 11000,
213 124,
214 10000,
215 3711,
216 7600,
217 12,
218 131,
219 132,
220 1731,
221 200,
222 300,
223 3100,
224 112,
225 12300,
226 8000,
227 141,
228 1441,
229 1600,
230 12600,
231 1421,
232 101,
233 111,
234 1711,
235 3000,
236 1000,
237 1100,
238 2100,
239 12800,
240 1500,
241 12400,
242 500,
243 3200,
244 7400,
245 1800,
246 122,
247 1722,
248 7100,
249 6300,
250 6700,
251 6400,
252 6500,
253 2400,
254 2410,
255 5700,
256 9200,
257 9300,
258 22,
259 501,
260 5800,
261 8100,
262 8500,
263 7200,
264 9900,
265 7700,
266 7800,
267 10300,
268 8600,
269 8700,
270 9100,
271 133,
272 13500,
273 11600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 8800,
283 12900,
284 12200,
285 9700,
286 9710,
287 9800,
288 9810,
289 9400,
290 9500,
291 9600,
292 10400,
293 10410,
294 10500,
295 10600,
296 10700,
297 9000,
298 5200,
299 6800,
300 6600,
301 8200,
302 11300,
303 12700,
304 13400,
305 125
306 };
307
308 /**
309 * types
310 */
311
312 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
313
314 /**
315 * globals
316 */
317
318 static unsigned int full01 = 0x01010101;
319 static unsigned int full80 = 0x80808080;
320
321 int SUPPRESS_OUTPUT = 0;
322
323 hc_thread_mutex_t mux_adl;
324 hc_thread_mutex_t mux_counter;
325 hc_thread_mutex_t mux_dispatcher;
326 hc_thread_mutex_t mux_display;
327
328 hc_global_data_t data;
329
330 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
331
332 const char *USAGE_MINI[] =
333 {
334 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
335 "",
336 "Try --help for more help.",
337 NULL
338 };
339
340 const char *USAGE_BIG[] =
341 {
342 "%s, advanced password recovery",
343 "",
344 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
345 "",
346 "=======",
347 "Options",
348 "=======",
349 "",
350 "* General:",
351 "",
352 " -m, --hash-type=NUM Hash-type, see references below",
353 " -a, --attack-mode=NUM Attack-mode, see references below",
354 " -V, --version Print version",
355 " -h, --help Print help",
356 " --quiet Suppress output",
357 "",
358 "* Misc:",
359 "",
360 " --hex-charset Assume charset is given in hex",
361 " --hex-salt Assume salt is given in hex",
362 " --hex-wordlist Assume words in wordlist is given in hex",
363 " --force Ignore warnings",
364 " --status Enable automatic update of the status-screen",
365 " --status-timer=NUM Seconds between status-screen update",
366 " --status-automat Display the status view in a machine readable format",
367 " --loopback Add new plains to induct directory",
368 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
369 "",
370 "* Markov:",
371 "",
372 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
373 " --markov-disable Disables markov-chains, emulates classic brute-force",
374 " --markov-classic Enables classic markov-chains, no per-position enhancement",
375 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
376 "",
377 "* Session:",
378 "",
379 " --runtime=NUM Abort session after NUM seconds of runtime",
380 " --session=STR Define specific session name",
381 " --restore Restore session from --session",
382 " --restore-disable Do not write restore file",
383 "",
384 "* Files:",
385 "",
386 " -o, --outfile=FILE Define outfile for recovered hash",
387 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
388 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
389 " --outfile-check-timer=NUM Seconds between outfile checks",
390 " -p, --separator=CHAR Separator char for hashlists and outfile",
391 " --show Show cracked passwords only",
392 " --left Show un-cracked passwords only",
393 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
394 " --remove Enable remove of hash once it is cracked",
395 " --remove-timer=NUM Update input hash file each NUM seconds",
396 " --potfile-disable Do not write potfile",
397 " --potfile-path Specific path to potfile",
398 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
399 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
400 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
401 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
402 " --logfile-disable Disable the logfile",
403 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
404 "",
405 "* Resources:",
406 "",
407 " -b, --benchmark Run benchmark",
408 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
409 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
410 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
411 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
412 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
413 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
414 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
415 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
416 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
417 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
418 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
419 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
420 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
421 #ifdef HAVE_HWMON
422 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
423 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
424 #ifdef HAVE_ADL
425 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
426 #endif
427 #endif
428 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
429 "",
430 "* Distributed:",
431 "",
432 " -s, --skip=NUM Skip number of words",
433 " -l, --limit=NUM Limit number of words",
434 " --keyspace Show keyspace base:mod values and quit",
435 "",
436 "* Rules:",
437 "",
438 " -j, --rule-left=RULE Single rule applied to each word from left dict",
439 " -k, --rule-right=RULE Single rule applied to each word from right dict",
440 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
441 " -g, --generate-rules=NUM Generate NUM random rules",
442 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
443 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
444 " --generate-rules-seed=NUM Force RNG seed to NUM",
445 "",
446 "* Custom charsets:",
447 "",
448 " -1, --custom-charset1=CS User-defined charsets",
449 " -2, --custom-charset2=CS Example:",
450 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
451 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
452 "",
453 "* Increment:",
454 "",
455 " -i, --increment Enable increment mode",
456 " --increment-min=NUM Start incrementing at NUM",
457 " --increment-max=NUM Stop incrementing at NUM",
458 "",
459 "==========",
460 "References",
461 "==========",
462 "",
463 "* Workload Profile:",
464 "",
465 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
466 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
467 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
468 "",
469 "* OpenCL device-types:",
470 "",
471 " 1 = CPU devices",
472 " 2 = GPU devices",
473 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
474 "",
475 "* Outfile Formats:",
476 "",
477 " 1 = hash[:salt]",
478 " 2 = plain",
479 " 3 = hash[:salt]:plain",
480 " 4 = hex_plain",
481 " 5 = hash[:salt]:hex_plain",
482 " 6 = plain:hex_plain",
483 " 7 = hash[:salt]:plain:hex_plain",
484 " 8 = crackpos",
485 " 9 = hash[:salt]:crackpos",
486 " 10 = plain:crackpos",
487 " 11 = hash[:salt]:plain:crackpos",
488 " 12 = hex_plain:crackpos",
489 " 13 = hash[:salt]:hex_plain:crackpos",
490 " 14 = plain:hex_plain:crackpos",
491 " 15 = hash[:salt]:plain:hex_plain:crackpos",
492 "",
493 "* Debug mode output formats (for hybrid mode only, by using rules):",
494 "",
495 " 1 = save finding rule",
496 " 2 = save original word",
497 " 3 = save original word and finding rule",
498 " 4 = save original word, finding rule and modified plain",
499 "",
500 "* Built-in charsets:",
501 "",
502 " ?l = abcdefghijklmnopqrstuvwxyz",
503 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
504 " ?d = 0123456789",
505 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
506 " ?a = ?l?u?d?s",
507 " ?b = 0x00 - 0xff",
508 "",
509 "* Attack modes:",
510 "",
511 " 0 = Straight",
512 " 1 = Combination",
513 " 3 = Brute-force",
514 " 6 = Hybrid dict + mask",
515 " 7 = Hybrid mask + dict",
516 "",
517 "* Hash types:",
518 "",
519 "[[ Roll-your-own: Raw Hashes ]]",
520 "",
521 " 900 = MD4",
522 " 0 = MD5",
523 " 5100 = Half MD5",
524 " 100 = SHA1",
525 " 10800 = SHA-384",
526 " 1400 = SHA-256",
527 " 1700 = SHA-512",
528 " 5000 = SHA-3(Keccak)",
529 " 10100 = SipHash",
530 " 6000 = RipeMD160",
531 " 6100 = Whirlpool",
532 " 6900 = GOST R 34.11-94",
533 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
534 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
535 "",
536 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
537 "",
538 " 10 = md5($pass.$salt)",
539 " 20 = md5($salt.$pass)",
540 " 30 = md5(unicode($pass).$salt)",
541 " 40 = md5($salt.unicode($pass))",
542 " 3800 = md5($salt.$pass.$salt)",
543 " 3710 = md5($salt.md5($pass))",
544 " 2600 = md5(md5($pass)",
545 " 4300 = md5(strtoupper(md5($pass)))",
546 " 4400 = md5(sha1($pass))",
547 " 110 = sha1($pass.$salt)",
548 " 120 = sha1($salt.$pass)",
549 " 130 = sha1(unicode($pass).$salt)",
550 " 140 = sha1($salt.unicode($pass))",
551 " 4500 = sha1(sha1($pass)",
552 " 4700 = sha1(md5($pass))",
553 " 4900 = sha1($salt.$pass.$salt)",
554 " 1410 = sha256($pass.$salt)",
555 " 1420 = sha256($salt.$pass)",
556 " 1430 = sha256(unicode($pass).$salt)",
557 " 1440 = sha256($salt.unicode($pass))",
558 " 1710 = sha512($pass.$salt)",
559 " 1720 = sha512($salt.$pass)",
560 " 1730 = sha512(unicode($pass).$salt)",
561 " 1740 = sha512($salt.unicode($pass))",
562 "",
563 "[[ Roll-your-own: Authenticated Hashes ]]",
564 "",
565 " 50 = HMAC-MD5 (key = $pass)",
566 " 60 = HMAC-MD5 (key = $salt)",
567 " 150 = HMAC-SHA1 (key = $pass)",
568 " 160 = HMAC-SHA1 (key = $salt)",
569 " 1450 = HMAC-SHA256 (key = $pass)",
570 " 1460 = HMAC-SHA256 (key = $salt)",
571 " 1750 = HMAC-SHA512 (key = $pass)",
572 " 1760 = HMAC-SHA512 (key = $salt)",
573 "",
574 "[[ Generic KDF ]]",
575 "",
576 " 400 = phpass",
577 " 8900 = scrypt",
578 " 11900 = PBKDF2-HMAC-MD5",
579 " 12000 = PBKDF2-HMAC-SHA1",
580 " 10900 = PBKDF2-HMAC-SHA256",
581 " 12100 = PBKDF2-HMAC-SHA512",
582 "",
583 "[[ Network protocols, Challenge-Response ]]",
584 "",
585 " 23 = Skype",
586 " 2500 = WPA/WPA2",
587 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
588 " 5300 = IKE-PSK MD5",
589 " 5400 = IKE-PSK SHA1",
590 " 5500 = NetNTLMv1",
591 " 5500 = NetNTLMv1 + ESS",
592 " 5600 = NetNTLMv2",
593 " 7300 = IPMI2 RAKP HMAC-SHA1",
594 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
595 " 8300 = DNSSEC (NSEC3)",
596 " 10200 = Cram MD5",
597 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
598 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
599 " 11400 = SIP digest authentication (MD5)",
600 " 13100 = Kerberos 5 TGS-REP etype 23",
601 "",
602 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
603 "",
604 " 121 = SMF (Simple Machines Forum)",
605 " 400 = phpBB3",
606 " 2611 = vBulletin < v3.8.5",
607 " 2711 = vBulletin > v3.8.5",
608 " 2811 = MyBB",
609 " 2811 = IPB (Invison Power Board)",
610 " 8400 = WBB3 (Woltlab Burning Board)",
611 " 11 = Joomla < 2.5.18",
612 " 400 = Joomla > 2.5.18",
613 " 400 = Wordpress",
614 " 2612 = PHPS",
615 " 7900 = Drupal7",
616 " 21 = osCommerce",
617 " 21 = xt:Commerce",
618 " 11000 = PrestaShop",
619 " 124 = Django (SHA-1)",
620 " 10000 = Django (PBKDF2-SHA256)",
621 " 3711 = Mediawiki B type",
622 " 7600 = Redmine",
623 "",
624 "[[ Database Server ]]",
625 "",
626 " 12 = PostgreSQL",
627 " 131 = MSSQL(2000)",
628 " 132 = MSSQL(2005)",
629 " 1731 = MSSQL(2012)",
630 " 1731 = MSSQL(2014)",
631 " 200 = MySQL323",
632 " 300 = MySQL4.1/MySQL5",
633 " 3100 = Oracle H: Type (Oracle 7+)",
634 " 112 = Oracle S: Type (Oracle 11+)",
635 " 12300 = Oracle T: Type (Oracle 12+)",
636 " 8000 = Sybase ASE",
637 "",
638 "[[ HTTP, SMTP, LDAP Server ]]",
639 "",
640 " 141 = EPiServer 6.x < v4",
641 " 1441 = EPiServer 6.x > v4",
642 " 1600 = Apache $apr1$",
643 " 12600 = ColdFusion 10+",
644 " 1421 = hMailServer",
645 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
646 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
647 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
648 "",
649 "[[ Checksums ]]",
650 "",
651 " 11500 = CRC32",
652 "",
653 "[[ Operating-Systems ]]",
654 "",
655 " 3000 = LM",
656 " 1000 = NTLM",
657 " 1100 = Domain Cached Credentials (DCC), MS Cache",
658 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
659 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
660 " 1500 = descrypt, DES(Unix), Traditional DES",
661 " 12400 = BSDiCrypt, Extended DES",
662 " 500 = md5crypt $1$, MD5(Unix)",
663 " 3200 = bcrypt $2*$, Blowfish(Unix)",
664 " 7400 = sha256crypt $5$, SHA256(Unix)",
665 " 1800 = sha512crypt $6$, SHA512(Unix)",
666 " 122 = OSX v10.4",
667 " 122 = OSX v10.5",
668 " 122 = OSX v10.6",
669 " 1722 = OSX v10.7",
670 " 7100 = OSX v10.8",
671 " 7100 = OSX v10.9",
672 " 7100 = OSX v10.10",
673 " 6300 = AIX {smd5}",
674 " 6700 = AIX {ssha1}",
675 " 6400 = AIX {ssha256}",
676 " 6500 = AIX {ssha512}",
677 " 2400 = Cisco-PIX",
678 " 2410 = Cisco-ASA",
679 " 500 = Cisco-IOS $1$",
680 " 5700 = Cisco-IOS $4$",
681 " 9200 = Cisco-IOS $8$",
682 " 9300 = Cisco-IOS $9$",
683 " 22 = Juniper Netscreen/SSG (ScreenOS)",
684 " 501 = Juniper IVE",
685 " 5800 = Android PIN",
686 " 8100 = Citrix Netscaler",
687 " 8500 = RACF",
688 " 7200 = GRUB 2",
689 " 9900 = Radmin2",
690 " 125 = ArubaOS",
691 "",
692 "[[ Enterprise Application Software (EAS) ]]",
693 "",
694 " 7700 = SAP CODVN B (BCODE)",
695 " 7800 = SAP CODVN F/G (PASSCODE)",
696 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
697 " 8600 = Lotus Notes/Domino 5",
698 " 8700 = Lotus Notes/Domino 6",
699 " 9100 = Lotus Notes/Domino 8",
700 " 133 = PeopleSoft",
701 " 13500 = PeopleSoft Token",
702 "",
703 "[[ Archives ]]",
704 "",
705 " 11600 = 7-Zip",
706 " 12500 = RAR3-hp",
707 " 13000 = RAR5",
708 " 13200 = AxCrypt",
709 " 13300 = AxCrypt in memory SHA1",
710 "",
711 "[[ Full-Disk encryptions (FDE) ]]",
712 "",
713 " 62XY = TrueCrypt 5.0+",
714 " X = 1 = PBKDF2-HMAC-RipeMD160",
715 " X = 2 = PBKDF2-HMAC-SHA512",
716 " X = 3 = PBKDF2-HMAC-Whirlpool",
717 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
718 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
719 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
720 " Y = 3 = XTS 1536 bit (Ciphers: All)",
721 " 8800 = Android FDE < v4.3",
722 " 12900 = Android FDE (Samsung DEK)",
723 " 12200 = eCryptfs",
724 "",
725 "[[ Documents ]]",
726 "",
727 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
728 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
729 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
730 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
731 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
732 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
733 " 9400 = MS Office 2007",
734 " 9500 = MS Office 2010",
735 " 9600 = MS Office 2013",
736 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
737 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
738 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
739 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
740 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
741 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
742 "",
743 "[[ Password Managers ]]",
744 "",
745 " 9000 = Password Safe v2",
746 " 5200 = Password Safe v3",
747 " 6800 = Lastpass",
748 " 6600 = 1Password, agilekeychain",
749 " 8200 = 1Password, cloudkeychain",
750 " 11300 = Bitcoin/Litecoin wallet.dat",
751 " 12700 = Blockchain, My Wallet",
752 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
753 "",
754 NULL
755 };
756
757 /**
758 * oclHashcat specific functions
759 */
760
761 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
762 {
763 int exec_pos = (int) device_param->exec_pos - last_num_entries;
764
765 if (exec_pos < 0) exec_pos += EXEC_CACHE;
766
767 double exec_ms_sum = 0;
768
769 int exec_ms_cnt = 0;
770
771 for (int i = 0; i < last_num_entries; i++)
772 {
773 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
774
775 if (exec_ms)
776 {
777 exec_ms_sum += exec_ms;
778
779 exec_ms_cnt++;
780 }
781 }
782
783 if (exec_ms_cnt == 0) return 0;
784
785 return exec_ms_sum / exec_ms_cnt;
786 }
787
788 void status_display_automat ()
789 {
790 FILE *out = stdout;
791
792 fprintf (out, "STATUS\t%u\t", data.devices_status);
793
794 /**
795 * speed new
796 */
797
798 fprintf (out, "SPEED\t");
799
800 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
801 {
802 hc_device_param_t *device_param = &data.devices_param[device_id];
803
804 if (device_param->skipped) continue;
805
806 u64 speed_cnt = 0;
807 double speed_ms = 0;
808
809 for (int i = 0; i < SPEED_CACHE; i++)
810 {
811 speed_cnt += device_param->speed_cnt[i];
812 speed_ms += device_param->speed_ms[i];
813 }
814
815 speed_cnt /= SPEED_CACHE;
816 speed_ms /= SPEED_CACHE;
817
818 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
819 }
820
821 /**
822 * exec time
823 */
824
825 fprintf (out, "EXEC_RUNTIME\t");
826
827 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
828 {
829 hc_device_param_t *device_param = &data.devices_param[device_id];
830
831 if (device_param->skipped) continue;
832
833 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
834
835 fprintf (out, "%f\t", exec_ms_avg);
836 }
837
838 /**
839 * words_cur
840 */
841
842 u64 words_cur = get_lowest_words_done ();
843
844 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
845
846 /**
847 * counter
848 */
849
850 u64 progress_total = data.words_cnt * data.salts_cnt;
851
852 u64 all_done = 0;
853 u64 all_rejected = 0;
854 u64 all_restored = 0;
855
856 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
857 {
858 all_done += data.words_progress_done[salt_pos];
859 all_rejected += data.words_progress_rejected[salt_pos];
860 all_restored += data.words_progress_restored[salt_pos];
861 }
862
863 u64 progress_cur = all_restored + all_done + all_rejected;
864 u64 progress_end = progress_total;
865
866 u64 progress_skip = 0;
867
868 if (data.skip)
869 {
870 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
871
872 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
873 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
874 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
875 }
876
877 if (data.limit)
878 {
879 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
880
881 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
882 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
883 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
884 }
885
886 u64 progress_cur_relative_skip = progress_cur - progress_skip;
887 u64 progress_end_relative_skip = progress_end - progress_skip;
888
889 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
890
891 /**
892 * cracks
893 */
894
895 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
896 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
897
898 /**
899 * temperature
900 */
901
902 #ifdef HAVE_HWMON
903 if (data.gpu_temp_disable == 0)
904 {
905 fprintf (out, "TEMP\t");
906
907 hc_thread_mutex_lock (mux_adl);
908
909 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
910 {
911 hc_device_param_t *device_param = &data.devices_param[device_id];
912
913 if (device_param->skipped) continue;
914
915 int temp = hm_get_temperature_with_device_id (device_id);
916
917 fprintf (out, "%d\t", temp);
918 }
919
920 hc_thread_mutex_unlock (mux_adl);
921 }
922 #endif // HAVE_HWMON
923
924 /**
925 * flush
926 */
927
928 #ifdef _WIN
929 fputc ('\r', out);
930 fputc ('\n', out);
931 #endif
932
933 #ifdef _POSIX
934 fputc ('\n', out);
935 #endif
936
937 fflush (out);
938 }
939
940 void status_display ()
941 {
942 if (data.devices_status == STATUS_INIT) return;
943 if (data.devices_status == STATUS_STARTING) return;
944 if (data.devices_status == STATUS_BYPASS) return;
945
946 if (data.status_automat == 1)
947 {
948 status_display_automat ();
949
950 return;
951 }
952
953 char tmp_buf[1000] = { 0 };
954
955 uint tmp_len = 0;
956
957 log_info ("Session.Name...: %s", data.session);
958
959 char *status_type = strstatus (data.devices_status);
960
961 uint hash_mode = data.hash_mode;
962
963 char *hash_type = strhashtype (hash_mode); // not a bug
964
965 log_info ("Status.........: %s", status_type);
966
967 /**
968 * show rules
969 */
970
971 if (data.rp_files_cnt)
972 {
973 uint i;
974
975 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
976 {
977 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
978 }
979
980 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
981
982 log_info ("Rules.Type.....: %s", tmp_buf);
983
984 tmp_len = 0;
985 }
986
987 if (data.rp_gen)
988 {
989 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
990
991 if (data.rp_gen_seed)
992 {
993 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
994 }
995 }
996
997 /**
998 * show input
999 */
1000
1001 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1002 {
1003 if (data.wordlist_mode == WL_MODE_FILE)
1004 {
1005 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1006 }
1007 else if (data.wordlist_mode == WL_MODE_STDIN)
1008 {
1009 log_info ("Input.Mode.....: Pipe");
1010 }
1011 }
1012 else if (data.attack_mode == ATTACK_MODE_COMBI)
1013 {
1014 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1015 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1016 }
1017 else if (data.attack_mode == ATTACK_MODE_BF)
1018 {
1019 char *mask = data.mask;
1020
1021 if (mask != NULL)
1022 {
1023 uint mask_len = data.css_cnt;
1024
1025 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1026
1027 if (mask_len > 0)
1028 {
1029 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1030 {
1031 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1032 {
1033 mask_len -= data.salts_buf[0].salt_len;
1034 }
1035 }
1036
1037 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1038
1039 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1040 }
1041
1042 if (data.maskcnt > 1)
1043 {
1044 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1045
1046 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1047 }
1048
1049 log_info ("Input.Mode.....: %s", tmp_buf);
1050 }
1051
1052 tmp_len = 0;
1053 }
1054 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1055 {
1056 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1057 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1058 }
1059 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1060 {
1061 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1062 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1063 }
1064
1065 if (data.digests_cnt == 1)
1066 {
1067 if (data.hash_mode == 2500)
1068 {
1069 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1070
1071 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1072 (char *) data.salts_buf[0].salt_buf,
1073 wpa->orig_mac1[0],
1074 wpa->orig_mac1[1],
1075 wpa->orig_mac1[2],
1076 wpa->orig_mac1[3],
1077 wpa->orig_mac1[4],
1078 wpa->orig_mac1[5],
1079 wpa->orig_mac2[0],
1080 wpa->orig_mac2[1],
1081 wpa->orig_mac2[2],
1082 wpa->orig_mac2[3],
1083 wpa->orig_mac2[4],
1084 wpa->orig_mac2[5]);
1085 }
1086 else if (data.hash_mode == 5200)
1087 {
1088 log_info ("Hash.Target....: File (%s)", data.hashfile);
1089 }
1090 else if (data.hash_mode == 9000)
1091 {
1092 log_info ("Hash.Target....: File (%s)", data.hashfile);
1093 }
1094 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1095 {
1096 log_info ("Hash.Target....: File (%s)", data.hashfile);
1097 }
1098 else
1099 {
1100 char out_buf[HCBUFSIZ] = { 0 };
1101
1102 ascii_digest (out_buf, 0, 0);
1103
1104 // limit length
1105 if (strlen (out_buf) > 40)
1106 {
1107 out_buf[41] = '.';
1108 out_buf[42] = '.';
1109 out_buf[43] = '.';
1110 out_buf[44] = 0;
1111 }
1112
1113 log_info ("Hash.Target....: %s", out_buf);
1114 }
1115 }
1116 else
1117 {
1118 if (data.hash_mode == 3000)
1119 {
1120 char out_buf1[32] = { 0 };
1121 char out_buf2[32] = { 0 };
1122
1123 ascii_digest (out_buf1, 0, 0);
1124 ascii_digest (out_buf2, 0, 1);
1125
1126 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1127 }
1128 else
1129 {
1130 log_info ("Hash.Target....: File (%s)", data.hashfile);
1131 }
1132 }
1133
1134 log_info ("Hash.Type......: %s", hash_type);
1135
1136 /**
1137 * speed new
1138 */
1139
1140 u64 speed_cnt[DEVICES_MAX] = { 0 };
1141 double speed_ms[DEVICES_MAX] = { 0 };
1142
1143 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1144 {
1145 hc_device_param_t *device_param = &data.devices_param[device_id];
1146
1147 if (device_param->skipped) continue;
1148
1149 speed_cnt[device_id] = 0;
1150 speed_ms[device_id] = 0;
1151
1152 for (int i = 0; i < SPEED_CACHE; i++)
1153 {
1154 speed_cnt[device_id] += device_param->speed_cnt[i];
1155 speed_ms[device_id] += device_param->speed_ms[i];
1156 }
1157
1158 speed_cnt[device_id] /= SPEED_CACHE;
1159 speed_ms[device_id] /= SPEED_CACHE;
1160 }
1161
1162 float hashes_all_ms = 0;
1163
1164 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1165
1166 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1167 {
1168 hc_device_param_t *device_param = &data.devices_param[device_id];
1169
1170 if (device_param->skipped) continue;
1171
1172 hashes_dev_ms[device_id] = 0;
1173
1174 if (speed_ms[device_id])
1175 {
1176 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1177
1178 hashes_all_ms += hashes_dev_ms[device_id];
1179 }
1180 }
1181
1182 /**
1183 * exec time
1184 */
1185
1186 double exec_all_ms[DEVICES_MAX] = { 0 };
1187
1188 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1189 {
1190 hc_device_param_t *device_param = &data.devices_param[device_id];
1191
1192 if (device_param->skipped) continue;
1193
1194 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1195
1196 exec_all_ms[device_id] = exec_ms_avg;
1197 }
1198
1199 /**
1200 * timers
1201 */
1202
1203 double ms_running = 0;
1204
1205 hc_timer_get (data.timer_running, ms_running);
1206
1207 double ms_paused = data.ms_paused;
1208
1209 if (data.devices_status == STATUS_PAUSED)
1210 {
1211 double ms_paused_tmp = 0;
1212
1213 hc_timer_get (data.timer_paused, ms_paused_tmp);
1214
1215 ms_paused += ms_paused_tmp;
1216 }
1217
1218 #ifdef WIN
1219
1220 __time64_t sec_run = ms_running / 1000;
1221
1222 #else
1223
1224 time_t sec_run = ms_running / 1000;
1225
1226 #endif
1227
1228 if (sec_run)
1229 {
1230 char display_run[32] = { 0 };
1231
1232 struct tm tm_run;
1233
1234 struct tm *tmp = NULL;
1235
1236 #ifdef WIN
1237
1238 tmp = _gmtime64 (&sec_run);
1239
1240 #else
1241
1242 tmp = gmtime (&sec_run);
1243
1244 #endif
1245
1246 if (tmp != NULL)
1247 {
1248 memset (&tm_run, 0, sizeof (tm_run));
1249
1250 memcpy (&tm_run, tmp, sizeof (tm_run));
1251
1252 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1253
1254 char *start = ctime (&data.proc_start);
1255
1256 size_t start_len = strlen (start);
1257
1258 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1259 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1260
1261 log_info ("Time.Started...: %s (%s)", start, display_run);
1262 }
1263 }
1264 else
1265 {
1266 log_info ("Time.Started...: 0 secs");
1267 }
1268
1269 /**
1270 * counters
1271 */
1272
1273 u64 progress_total = data.words_cnt * data.salts_cnt;
1274
1275 u64 all_done = 0;
1276 u64 all_rejected = 0;
1277 u64 all_restored = 0;
1278
1279 u64 progress_noneed = 0;
1280
1281 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1282 {
1283 all_done += data.words_progress_done[salt_pos];
1284 all_rejected += data.words_progress_rejected[salt_pos];
1285 all_restored += data.words_progress_restored[salt_pos];
1286
1287 // Important for ETA only
1288
1289 if (data.salts_shown[salt_pos] == 1)
1290 {
1291 const u64 all = data.words_progress_done[salt_pos]
1292 + data.words_progress_rejected[salt_pos]
1293 + data.words_progress_restored[salt_pos];
1294
1295 const u64 left = data.words_cnt - all;
1296
1297 progress_noneed += left;
1298 }
1299 }
1300
1301 u64 progress_cur = all_restored + all_done + all_rejected;
1302 u64 progress_end = progress_total;
1303
1304 u64 progress_skip = 0;
1305
1306 if (data.skip)
1307 {
1308 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1309
1310 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1311 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1312 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1313 }
1314
1315 if (data.limit)
1316 {
1317 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1318
1319 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1320 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1321 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1322 }
1323
1324 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1325 u64 progress_end_relative_skip = progress_end - progress_skip;
1326
1327 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1328 {
1329 if (data.devices_status != STATUS_CRACKED)
1330 {
1331 #ifdef WIN
1332 __time64_t sec_etc = 0;
1333 #else
1334 time_t sec_etc = 0;
1335 #endif
1336
1337 if (hashes_all_ms)
1338 {
1339 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1340
1341 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1342
1343 sec_etc = ms_left / 1000;
1344 }
1345
1346 if (sec_etc == 0)
1347 {
1348 //log_info ("Time.Estimated.: 0 secs");
1349 }
1350 else if ((u64) sec_etc > ETC_MAX)
1351 {
1352 log_info ("Time.Estimated.: > 10 Years");
1353 }
1354 else
1355 {
1356 char display_etc[32] = { 0 };
1357
1358 struct tm tm_etc;
1359
1360 struct tm *tmp = NULL;
1361
1362 #ifdef WIN
1363
1364 tmp = _gmtime64 (&sec_etc);
1365
1366 #else
1367
1368 tmp = gmtime (&sec_etc);
1369
1370 #endif
1371
1372 if (tmp != NULL)
1373 {
1374 memset (&tm_etc, 0, sizeof (tm_etc));
1375
1376 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1377
1378 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1379
1380 time_t now;
1381
1382 time (&now);
1383
1384 now += sec_etc;
1385
1386 char *etc = ctime (&now);
1387
1388 size_t etc_len = strlen (etc);
1389
1390 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1391 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1392
1393 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1394 }
1395 }
1396 }
1397 }
1398
1399 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1400 {
1401 hc_device_param_t *device_param = &data.devices_param[device_id];
1402
1403 if (device_param->skipped) continue;
1404
1405 char display_dev_cur[16] = { 0 };
1406
1407 strncpy (display_dev_cur, "0.00", 4);
1408
1409 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1410
1411 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1412 }
1413
1414 char display_all_cur[16] = { 0 };
1415
1416 strncpy (display_all_cur, "0.00", 4);
1417
1418 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1419
1420 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1421
1422 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1423 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1424
1425 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);
1426
1427 // crack-per-time
1428
1429 if (data.digests_cnt > 100)
1430 {
1431 time_t now = time (NULL);
1432
1433 int cpt_cur_min = 0;
1434 int cpt_cur_hour = 0;
1435 int cpt_cur_day = 0;
1436
1437 for (int i = 0; i < CPT_BUF; i++)
1438 {
1439 const uint cracked = data.cpt_buf[i].cracked;
1440 const time_t timestamp = data.cpt_buf[i].timestamp;
1441
1442 if ((timestamp + 60) > now)
1443 {
1444 cpt_cur_min += cracked;
1445 }
1446
1447 if ((timestamp + 3600) > now)
1448 {
1449 cpt_cur_hour += cracked;
1450 }
1451
1452 if ((timestamp + 86400) > now)
1453 {
1454 cpt_cur_day += cracked;
1455 }
1456 }
1457
1458 double ms_real = ms_running - ms_paused;
1459
1460 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1461 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1462 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1463
1464 if ((data.cpt_start + 86400) < now)
1465 {
1466 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1467 cpt_cur_min,
1468 cpt_cur_hour,
1469 cpt_cur_day,
1470 cpt_avg_min,
1471 cpt_avg_hour,
1472 cpt_avg_day);
1473 }
1474 else if ((data.cpt_start + 3600) < now)
1475 {
1476 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1477 cpt_cur_min,
1478 cpt_cur_hour,
1479 cpt_avg_min,
1480 cpt_avg_hour,
1481 cpt_avg_day);
1482 }
1483 else if ((data.cpt_start + 60) < now)
1484 {
1485 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1486 cpt_cur_min,
1487 cpt_avg_min,
1488 cpt_avg_hour,
1489 cpt_avg_day);
1490 }
1491 else
1492 {
1493 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1494 cpt_avg_min,
1495 cpt_avg_hour,
1496 cpt_avg_day);
1497 }
1498 }
1499
1500 // Restore point
1501
1502 u64 restore_point = get_lowest_words_done ();
1503
1504 u64 restore_total = data.words_base;
1505
1506 float percent_restore = 0;
1507
1508 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1509
1510 if (progress_end_relative_skip)
1511 {
1512 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1513 {
1514 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1515 float percent_rejected = 0.0;
1516
1517 if (progress_cur)
1518 {
1519 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1520 }
1521
1522 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);
1523 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1524
1525 if (data.restore_disable == 0)
1526 {
1527 if (percent_finished != 1)
1528 {
1529 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1530 }
1531 }
1532 }
1533 }
1534 else
1535 {
1536 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1537 {
1538 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1539 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1540
1541 if (data.restore_disable == 0)
1542 {
1543 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1544 }
1545 }
1546 else
1547 {
1548 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1549 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1550
1551 // --restore not allowed if stdin is used -- really? why?
1552
1553 //if (data.restore_disable == 0)
1554 //{
1555 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1556 //}
1557 }
1558 }
1559
1560 #ifdef HAVE_HWMON
1561 if (data.gpu_temp_disable == 0)
1562 {
1563 hc_thread_mutex_lock (mux_adl);
1564
1565 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1566 {
1567 hc_device_param_t *device_param = &data.devices_param[device_id];
1568
1569 if (device_param->skipped) continue;
1570
1571 #define HM_STR_BUF_SIZE 255
1572
1573 if (data.hm_device[device_id].fan_supported == 1)
1574 {
1575 char utilization[HM_STR_BUF_SIZE] = { 0 };
1576 char temperature[HM_STR_BUF_SIZE] = { 0 };
1577 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1578
1579 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1580 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1581
1582 if (device_param->vendor_id == VENDOR_ID_AMD)
1583 {
1584 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1585 }
1586 else if (device_param->vendor_id == VENDOR_ID_NV)
1587 {
1588 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1589 }
1590
1591 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1592 }
1593 else
1594 {
1595 char utilization[HM_STR_BUF_SIZE] = { 0 };
1596 char temperature[HM_STR_BUF_SIZE] = { 0 };
1597
1598 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1599 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1600
1601 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1602 }
1603 }
1604
1605 hc_thread_mutex_unlock (mux_adl);
1606 }
1607 #endif // HAVE_HWMON
1608 }
1609
1610 static void status_benchmark ()
1611 {
1612 if (data.devices_status == STATUS_INIT) return;
1613 if (data.devices_status == STATUS_STARTING) return;
1614
1615 if (data.words_cnt == 0) return;
1616
1617 u64 speed_cnt[DEVICES_MAX] = { 0 };
1618 double speed_ms[DEVICES_MAX] = { 0 };
1619
1620 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1621 {
1622 hc_device_param_t *device_param = &data.devices_param[device_id];
1623
1624 if (device_param->skipped) continue;
1625
1626 speed_cnt[device_id] = device_param->speed_cnt[0];
1627 speed_ms[device_id] = device_param->speed_ms[0];
1628 }
1629
1630 float hashes_all_ms = 0;
1631
1632 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1633
1634 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1635 {
1636 hc_device_param_t *device_param = &data.devices_param[device_id];
1637
1638 if (device_param->skipped) continue;
1639
1640 hashes_dev_ms[device_id] = 0;
1641
1642 if (speed_ms[device_id])
1643 {
1644 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1645
1646 hashes_all_ms += hashes_dev_ms[device_id];
1647 }
1648 }
1649
1650 /**
1651 * exec time
1652 */
1653
1654 double exec_all_ms[DEVICES_MAX] = { 0 };
1655
1656 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1657 {
1658 hc_device_param_t *device_param = &data.devices_param[device_id];
1659
1660 if (device_param->skipped) continue;
1661
1662 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1663
1664 exec_all_ms[device_id] = exec_ms_avg;
1665 }
1666
1667 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1668 {
1669 hc_device_param_t *device_param = &data.devices_param[device_id];
1670
1671 if (device_param->skipped) continue;
1672
1673 char display_dev_cur[16] = { 0 };
1674
1675 strncpy (display_dev_cur, "0.00", 4);
1676
1677 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1678
1679 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1680 }
1681
1682 char display_all_cur[16] = { 0 };
1683
1684 strncpy (display_all_cur, "0.00", 4);
1685
1686 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1687
1688 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1689 }
1690
1691 /**
1692 * oclHashcat -only- functions
1693 */
1694
1695 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1696 {
1697 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1698 {
1699 if (attack_kern == ATTACK_KERN_STRAIGHT)
1700 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1701 else if (attack_kern == ATTACK_KERN_COMBI)
1702 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1703 else if (attack_kern == ATTACK_KERN_BF)
1704 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1705 }
1706 else
1707 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1708 }
1709
1710 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)
1711 {
1712 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1713 {
1714 if (attack_kern == ATTACK_KERN_STRAIGHT)
1715 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1716 else if (attack_kern == ATTACK_KERN_COMBI)
1717 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1718 else if (attack_kern == ATTACK_KERN_BF)
1719 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1720 }
1721 else
1722 {
1723 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1724 }
1725 }
1726
1727 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1728 {
1729 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1730 {
1731 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1732 }
1733 else
1734 {
1735 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1736 }
1737 }
1738
1739 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)
1740 {
1741 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1742 {
1743 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1744 }
1745 else
1746 {
1747 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1748 }
1749 }
1750
1751 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1752 {
1753 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1754 }
1755
1756 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1757 {
1758 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1759 }
1760
1761 static uint convert_from_hex (char *line_buf, const uint line_len)
1762 {
1763 if (line_len & 1) return (line_len); // not in hex
1764
1765 if (data.hex_wordlist == 1)
1766 {
1767 uint i;
1768 uint j;
1769
1770 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1771 {
1772 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1773 }
1774
1775 memset (line_buf + i, 0, line_len - i);
1776
1777 return (i);
1778 }
1779 else if (line_len >= 6) // $HEX[] = 6
1780 {
1781 if (line_buf[0] != '$') return (line_len);
1782 if (line_buf[1] != 'H') return (line_len);
1783 if (line_buf[2] != 'E') return (line_len);
1784 if (line_buf[3] != 'X') return (line_len);
1785 if (line_buf[4] != '[') return (line_len);
1786 if (line_buf[line_len - 1] != ']') return (line_len);
1787
1788 uint i;
1789 uint j;
1790
1791 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1792 {
1793 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1794 }
1795
1796 memset (line_buf + i, 0, line_len - i);
1797
1798 return (i);
1799 }
1800
1801 return (line_len);
1802 }
1803
1804 static void clear_prompt ()
1805 {
1806 fputc ('\r', stdout);
1807
1808 for (size_t i = 0; i < strlen (PROMPT); i++)
1809 {
1810 fputc (' ', stdout);
1811 }
1812
1813 fputc ('\r', stdout);
1814
1815 fflush (stdout);
1816 }
1817
1818 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1819 {
1820 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);
1821 }
1822
1823 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1824 {
1825 char *outfile = data.outfile;
1826 uint quiet = data.quiet;
1827 FILE *pot_fp = data.pot_fp;
1828 uint loopback = data.loopback;
1829 uint debug_mode = data.debug_mode;
1830 char *debug_file = data.debug_file;
1831
1832 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1833 int debug_rule_len = 0; // -1 error
1834 uint debug_plain_len = 0;
1835
1836 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1837
1838 // hash
1839
1840 char out_buf[HCBUFSIZ] = { 0 };
1841
1842 ascii_digest (out_buf, salt_pos, digest_pos);
1843
1844 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1845
1846 // plain
1847
1848 plain_t plain;
1849
1850 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);
1851
1852 uint gidvid = plain.gidvid;
1853 uint il_pos = plain.il_pos;
1854
1855 u64 crackpos = device_param->words_off;
1856
1857 uint plain_buf[16] = { 0 };
1858
1859 u8 *plain_ptr = (u8 *) plain_buf;
1860 unsigned int plain_len = 0;
1861
1862 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1863 {
1864 u64 gidd = gidvid;
1865 u64 gidm = 0;
1866
1867 pw_t pw;
1868
1869 gidd_to_pw_t (device_param, gidd, &pw);
1870
1871 for (int i = 0, j = gidm; i < 16; i++, j++)
1872 {
1873 plain_buf[i] = pw.i[j];
1874 }
1875
1876 plain_len = pw.pw_len;
1877
1878 const uint off = device_param->innerloop_pos + il_pos;
1879
1880 if (debug_mode > 0)
1881 {
1882 debug_rule_len = 0;
1883
1884 // save rule
1885 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1886 {
1887 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1888
1889 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1890 }
1891
1892 // save plain
1893 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1894 {
1895 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1896
1897 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1898
1899 debug_plain_len = plain_len;
1900 }
1901 }
1902
1903 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1904
1905 crackpos += gidvid;
1906 crackpos *= data.kernel_rules_cnt;
1907 crackpos += device_param->innerloop_pos + il_pos;
1908
1909 if (plain_len > data.pw_max) plain_len = data.pw_max;
1910 }
1911 else if (data.attack_mode == ATTACK_MODE_COMBI)
1912 {
1913 u64 gidd = gidvid;
1914 u64 gidm = 0;
1915
1916 pw_t pw;
1917
1918 gidd_to_pw_t (device_param, gidd, &pw);
1919
1920 for (int i = 0, j = gidm; i < 16; i++, j++)
1921 {
1922 plain_buf[i] = pw.i[j];
1923 }
1924
1925 plain_len = pw.pw_len;
1926
1927 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1928 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1929
1930 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1931 {
1932 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1933 }
1934 else
1935 {
1936 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1937
1938 memcpy (plain_ptr, comb_buf, comb_len);
1939 }
1940
1941 plain_len += comb_len;
1942
1943 crackpos += gidvid;
1944 crackpos *= data.combs_cnt;
1945 crackpos += device_param->innerloop_pos + il_pos;
1946
1947 if (data.pw_max != PW_DICTMAX1)
1948 {
1949 if (plain_len > data.pw_max) plain_len = data.pw_max;
1950 }
1951 }
1952 else if (data.attack_mode == ATTACK_MODE_BF)
1953 {
1954 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1955 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1956
1957 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1958 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1959
1960 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1961 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1962
1963 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1964 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1965
1966 plain_len = data.css_cnt;
1967
1968 crackpos += gidvid;
1969 crackpos *= data.bfs_cnt;
1970 crackpos += device_param->innerloop_pos + il_pos;
1971 }
1972 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1973 {
1974 u64 gidd = gidvid;
1975 u64 gidm = 0;
1976
1977 pw_t pw;
1978
1979 gidd_to_pw_t (device_param, gidd, &pw);
1980
1981 for (int i = 0, j = gidm; i < 16; i++, j++)
1982 {
1983 plain_buf[i] = pw.i[j];
1984 }
1985
1986 plain_len = pw.pw_len;
1987
1988 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1989
1990 uint start = 0;
1991 uint stop = device_param->kernel_params_mp_buf32[4];
1992
1993 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1994
1995 plain_len += start + stop;
1996
1997 crackpos += gidvid;
1998 crackpos *= data.combs_cnt;
1999 crackpos += device_param->innerloop_pos + il_pos;
2000
2001 if (data.pw_max != PW_DICTMAX1)
2002 {
2003 if (plain_len > data.pw_max) plain_len = data.pw_max;
2004 }
2005 }
2006 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2007 {
2008 u64 gidd = gidvid;
2009 u64 gidm = 0;
2010
2011 pw_t pw;
2012
2013 gidd_to_pw_t (device_param, gidd, &pw);
2014
2015 for (int i = 0, j = gidm; i < 16; i++, j++)
2016 {
2017 plain_buf[i] = pw.i[j];
2018 }
2019
2020 plain_len = pw.pw_len;
2021
2022 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2023
2024 uint start = 0;
2025 uint stop = device_param->kernel_params_mp_buf32[4];
2026
2027 memmove (plain_ptr + stop, plain_ptr, plain_len);
2028
2029 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2030
2031 plain_len += start + stop;
2032
2033 crackpos += gidvid;
2034 crackpos *= data.combs_cnt;
2035 crackpos += device_param->innerloop_pos + il_pos;
2036
2037 if (data.pw_max != PW_DICTMAX1)
2038 {
2039 if (plain_len > data.pw_max) plain_len = data.pw_max;
2040 }
2041 }
2042
2043 if (data.attack_mode == ATTACK_MODE_BF)
2044 {
2045 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2046 {
2047 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2048 {
2049 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2050 {
2051 plain_len = plain_len - data.salts_buf[0].salt_len;
2052 }
2053 }
2054
2055 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2056 {
2057 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2058 {
2059 plain_ptr[j] = plain_ptr[i];
2060 }
2061
2062 plain_len = plain_len / 2;
2063 }
2064 }
2065 }
2066
2067 // if enabled, update also the potfile
2068
2069 if (pot_fp)
2070 {
2071 lock_file (pot_fp);
2072
2073 fprintf (pot_fp, "%s:", out_buf);
2074
2075 format_plain (pot_fp, plain_ptr, plain_len, 1);
2076
2077 fputc ('\n', pot_fp);
2078
2079 fflush (pot_fp);
2080
2081 unlock_file (pot_fp);
2082 }
2083
2084 // outfile
2085
2086 FILE *out_fp = NULL;
2087
2088 if (outfile != NULL)
2089 {
2090 if ((out_fp = fopen (outfile, "ab")) == NULL)
2091 {
2092 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2093
2094 out_fp = stdout;
2095 }
2096 lock_file (out_fp);
2097 }
2098 else
2099 {
2100 out_fp = stdout;
2101
2102 if (quiet == 0) clear_prompt ();
2103 }
2104
2105 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2106
2107 if (outfile != NULL)
2108 {
2109 if (out_fp != stdout)
2110 {
2111 fclose (out_fp);
2112 }
2113 }
2114 else
2115 {
2116 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2117 {
2118 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2119 {
2120 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2121 if (quiet == 0) fflush (stdout);
2122 }
2123 }
2124 }
2125
2126 // loopback
2127
2128 if (loopback)
2129 {
2130 char *loopback_file = data.loopback_file;
2131
2132 FILE *fb_fp = NULL;
2133
2134 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2135 {
2136 lock_file (fb_fp);
2137
2138 format_plain (fb_fp, plain_ptr, plain_len, 1);
2139
2140 fputc ('\n', fb_fp);
2141
2142 fclose (fb_fp);
2143 }
2144 }
2145
2146 // (rule) debug mode
2147
2148 // the next check implies that:
2149 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2150 // - debug_mode > 0
2151
2152 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2153 {
2154 if (debug_rule_len < 0) debug_rule_len = 0;
2155
2156 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2157
2158 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2159
2160 if ((quiet == 0) && (debug_file == NULL))
2161 {
2162 fprintf (stdout, "%s", PROMPT);
2163 fflush (stdout);
2164 }
2165 }
2166 }
2167
2168 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2169 {
2170 salt_t *salt_buf = &data.salts_buf[salt_pos];
2171
2172 int found = 0;
2173
2174 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);
2175
2176 for (uint i = 0; i < device_param->kernel_threads; i++) if (device_param->result[i] == 1) found = 1;
2177
2178 if (found == 1)
2179 {
2180 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2181
2182 log_info_nn ("");
2183
2184 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);
2185
2186 uint cpt_cracked = 0;
2187
2188 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2189 {
2190 uint idx = salt_buf->digests_offset + digest_pos;
2191
2192 if (data.digests_shown_tmp[idx] == 0) continue;
2193
2194 if (data.digests_shown[idx] == 1) continue;
2195
2196 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2197 {
2198 data.digests_shown[idx] = 1;
2199
2200 data.digests_done++;
2201
2202 cpt_cracked++;
2203
2204 salt_buf->digests_done++;
2205
2206 if (salt_buf->digests_done == salt_buf->digests_cnt)
2207 {
2208 data.salts_shown[salt_pos] = 1;
2209
2210 data.salts_done++;
2211 }
2212 }
2213
2214 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2215
2216 check_hash (device_param, salt_pos, digest_pos);
2217 }
2218
2219 if (cpt_cracked > 0)
2220 {
2221 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2222 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2223
2224 data.cpt_pos++;
2225
2226 data.cpt_total += cpt_cracked;
2227
2228 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2229 }
2230
2231 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2232 {
2233 // we need to reset cracked state on the device
2234 // otherwise host thinks again and again the hash was cracked
2235 // and returns invalid password each time
2236
2237 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2238
2239 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);
2240 }
2241
2242 memset (device_param->result, 0, device_param->size_results);
2243
2244 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);
2245 }
2246 }
2247
2248 static void save_hash ()
2249 {
2250 char *hashfile = data.hashfile;
2251
2252 char new_hashfile[256] = { 0 };
2253 char old_hashfile[256] = { 0 };
2254
2255 snprintf (new_hashfile, 255, "%s.new", hashfile);
2256 snprintf (old_hashfile, 255, "%s.old", hashfile);
2257
2258 unlink (new_hashfile);
2259
2260 char separator = data.separator;
2261
2262 FILE *fp = fopen (new_hashfile, "wb");
2263
2264 if (fp == NULL)
2265 {
2266 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2267
2268 exit (-1);
2269 }
2270
2271 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2272 {
2273 if (data.salts_shown[salt_pos] == 1) continue;
2274
2275 salt_t *salt_buf = &data.salts_buf[salt_pos];
2276
2277 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2278 {
2279 uint idx = salt_buf->digests_offset + digest_pos;
2280
2281 if (data.digests_shown[idx] == 1) continue;
2282
2283 if (data.hash_mode != 2500)
2284 {
2285 char out_buf[HCBUFSIZ] = { 0 };
2286
2287 if (data.username == 1)
2288 {
2289 user_t *user = data.hash_info[idx]->user;
2290
2291 uint i;
2292
2293 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2294
2295 fputc (separator, fp);
2296 }
2297
2298 ascii_digest (out_buf, salt_pos, digest_pos);
2299
2300 fputs (out_buf, fp);
2301
2302 log_out (fp, "");
2303 }
2304 else
2305 {
2306 hccap_t hccap;
2307
2308 to_hccap_t (&hccap, salt_pos, digest_pos);
2309
2310 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2311 }
2312 }
2313 }
2314
2315 fflush (fp);
2316
2317 fclose (fp);
2318
2319 unlink (old_hashfile);
2320
2321 if (rename (hashfile, old_hashfile) != 0)
2322 {
2323 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2324
2325 exit (-1);
2326 }
2327
2328 unlink (hashfile);
2329
2330 if (rename (new_hashfile, hashfile) != 0)
2331 {
2332 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2333
2334 exit (-1);
2335 }
2336
2337 unlink (old_hashfile);
2338 }
2339
2340 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2341 {
2342 // function called only in case kernel_power_all > words_left
2343
2344 float kernel_power_div = (float) (total_left) / kernel_power_all;
2345
2346 kernel_power_div += kernel_power_div / 100;
2347
2348 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2349
2350 while (kernel_power_new < total_left)
2351 {
2352 kernel_power_div += kernel_power_div / 100;
2353
2354 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2355 }
2356
2357 if (data.quiet == 0)
2358 {
2359 clear_prompt ();
2360
2361 log_info ("");
2362
2363 log_info ("INFO: approaching final keyspace, workload adjusted");
2364
2365 log_info ("");
2366
2367 fprintf (stdout, "%s", PROMPT);
2368
2369 fflush (stdout);
2370 }
2371
2372 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2373
2374 return kernel_power_div;
2375 }
2376
2377 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2378 {
2379 uint num_elements = num;
2380
2381 device_param->kernel_params_buf32[30] = data.combs_mode;
2382 device_param->kernel_params_buf32[31] = num;
2383
2384 uint kernel_threads = device_param->kernel_threads;
2385
2386 while (num_elements % kernel_threads) num_elements++;
2387
2388 cl_kernel kernel = NULL;
2389
2390 switch (kern_run)
2391 {
2392 case KERN_RUN_1: kernel = device_param->kernel1; break;
2393 case KERN_RUN_12: kernel = device_param->kernel12; break;
2394 case KERN_RUN_2: kernel = device_param->kernel2; break;
2395 case KERN_RUN_23: kernel = device_param->kernel23; break;
2396 case KERN_RUN_3: kernel = device_param->kernel3; break;
2397 }
2398
2399 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2400 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2401 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2402 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2403 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2404 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2405 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2406 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2407 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2408 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2409 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2410
2411 hc_timer_t timer;
2412
2413 hc_timer_set (&timer);
2414
2415 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2416 {
2417 const size_t global_work_size[3] = { num_elements, 32, 1 };
2418 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2419
2420 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2421 }
2422 else
2423 {
2424 size_t workgroup_size = 0;
2425
2426 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2427
2428 if (kern_run == KERN_RUN_2)
2429 {
2430 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2431 {
2432 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2433 }
2434 }
2435
2436 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2437
2438 while (num_elements % kernel_threads) num_elements++;
2439
2440 const size_t global_work_size[3] = { num_elements, 1, 1 };
2441 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2442
2443 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2444 }
2445
2446 hc_clFlush (data.ocl, device_param->command_queue);
2447
2448 hc_clFinish (data.ocl, device_param->command_queue);
2449
2450 if (event_update)
2451 {
2452 double exec_time;
2453
2454 hc_timer_get (timer, exec_time);
2455
2456 uint exec_pos = device_param->exec_pos;
2457
2458 device_param->exec_ms[exec_pos] = exec_time;
2459
2460 exec_pos++;
2461
2462 if (exec_pos == EXEC_CACHE)
2463 {
2464 exec_pos = 0;
2465 }
2466
2467 device_param->exec_pos = exec_pos;
2468 }
2469 }
2470
2471 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2472 {
2473 uint num_elements = num;
2474
2475 switch (kern_run)
2476 {
2477 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2478 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2479 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2480 }
2481
2482 // causes problems with special threads like in bcrypt
2483 // const uint kernel_threads = device_param->kernel_threads;
2484
2485 uint kernel_threads = device_param->kernel_threads;
2486
2487 while (num_elements % kernel_threads) num_elements++;
2488
2489 cl_kernel kernel = NULL;
2490
2491 switch (kern_run)
2492 {
2493 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2494 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2495 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2496 }
2497
2498 switch (kern_run)
2499 {
2500 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2501 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2502 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2503 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2504 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2505 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2506 break;
2507 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2508 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2509 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2510 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2511 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2512 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2513 break;
2514 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2515 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2516 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2517 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2518 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2519 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2520 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2521 break;
2522 }
2523
2524 size_t workgroup_size = 0;
2525
2526 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2527
2528 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2529
2530 const size_t global_work_size[3] = { num_elements, 1, 1 };
2531 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2532
2533 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2534
2535 hc_clFlush (data.ocl, device_param->command_queue);
2536
2537 hc_clFinish (data.ocl, device_param->command_queue);
2538 }
2539
2540 static void run_kernel_tm (hc_device_param_t *device_param)
2541 {
2542 const uint num_elements = 1024; // fixed
2543
2544 uint kernel_threads = 32;
2545
2546 cl_kernel kernel = device_param->kernel_tm;
2547
2548 size_t workgroup_size = 0;
2549
2550 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2551
2552 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2553
2554 const size_t global_work_size[3] = { num_elements, 1, 1 };
2555 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2556
2557 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2558
2559 hc_clFlush (data.ocl, device_param->command_queue);
2560
2561 hc_clFinish (data.ocl, device_param->command_queue);
2562 }
2563
2564 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2565 {
2566 uint num_elements = num;
2567
2568 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2569 device_param->kernel_params_amp_buf32[6] = num_elements;
2570
2571 // causes problems with special threads like in bcrypt
2572 // const uint kernel_threads = device_param->kernel_threads;
2573
2574 uint kernel_threads = device_param->kernel_threads;
2575
2576 while (num_elements % kernel_threads) num_elements++;
2577
2578 cl_kernel kernel = device_param->kernel_amp;
2579
2580 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2581 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2582
2583 size_t workgroup_size = 0;
2584
2585 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2586
2587 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2588
2589 const size_t global_work_size[3] = { num_elements, 1, 1 };
2590 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2591
2592 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2593
2594 hc_clFlush (data.ocl, device_param->command_queue);
2595
2596 hc_clFinish (data.ocl, device_param->command_queue);
2597 }
2598
2599 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2600 {
2601 int rc = -1;
2602
2603 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2604 {
2605 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2606
2607 const cl_uchar zero = 0;
2608
2609 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2610 }
2611
2612 if (rc != 0)
2613 {
2614 // NOTE: clEnqueueFillBuffer () always fails with -59
2615 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2616 // How's that possible, OpenCL 1.2 support is advertised??
2617 // We need to workaround...
2618
2619 #define FILLSZ 0x100000
2620
2621 char *tmp = (char *) mymalloc (FILLSZ);
2622
2623 for (size_t i = 0; i < size; i += FILLSZ)
2624 {
2625 const size_t left = size - i;
2626
2627 const size_t fillsz = MIN (FILLSZ, left);
2628
2629 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2630 }
2631
2632 myfree (tmp);
2633 }
2634 }
2635
2636 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)
2637 {
2638 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2639 {
2640 if (attack_mode == ATTACK_MODE_BF)
2641 {
2642 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2643 {
2644 const uint size_tm = 32 * sizeof (bs_word_t);
2645
2646 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2647
2648 run_kernel_tm (device_param);
2649
2650 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);
2651 }
2652 }
2653
2654 if (highest_pw_len < 16)
2655 {
2656 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2657 }
2658 else if (highest_pw_len < 32)
2659 {
2660 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2661 }
2662 else
2663 {
2664 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2665 }
2666 }
2667 else
2668 {
2669 run_kernel_amp (device_param, pws_cnt);
2670
2671 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2672
2673 if (opts_type & OPTS_TYPE_HOOK12)
2674 {
2675 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2676 }
2677
2678 uint iter = salt_buf->salt_iter;
2679
2680 uint loop_step = device_param->kernel_loops;
2681
2682 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2683 {
2684 uint loop_left = iter - loop_pos;
2685
2686 loop_left = MIN (loop_left, loop_step);
2687
2688 device_param->kernel_params_buf32[25] = loop_pos;
2689 device_param->kernel_params_buf32[26] = loop_left;
2690
2691 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2692
2693 if (data.devices_status == STATUS_CRACKED) break;
2694 if (data.devices_status == STATUS_ABORTED) break;
2695 if (data.devices_status == STATUS_QUIT) break;
2696
2697 /**
2698 * speed
2699 */
2700
2701 const float iter_part = (float) (loop_pos + loop_left) / iter;
2702
2703 const u64 perf_sum_all = pws_cnt * iter_part;
2704
2705 double speed_ms;
2706
2707 hc_timer_get (device_param->timer_speed, speed_ms);
2708
2709 const u32 speed_pos = device_param->speed_pos;
2710
2711 device_param->speed_cnt[speed_pos] = perf_sum_all;
2712
2713 device_param->speed_ms[speed_pos] = speed_ms;
2714 }
2715
2716 if (opts_type & OPTS_TYPE_HOOK23)
2717 {
2718 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2719
2720 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);
2721
2722 // do something with data
2723
2724 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);
2725 }
2726
2727 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2728 }
2729 }
2730
2731 static int run_rule_engine (const int rule_len, const char *rule_buf)
2732 {
2733 if (rule_len == 0)
2734 {
2735 return 0;
2736 }
2737 else if (rule_len == 1)
2738 {
2739 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2740 }
2741
2742 return 1;
2743 }
2744
2745 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2746 {
2747 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2748 {
2749 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);
2750 }
2751 else if (data.attack_kern == ATTACK_KERN_COMBI)
2752 {
2753 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2754 {
2755 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2756 {
2757 for (u32 i = 0; i < pws_cnt; i++)
2758 {
2759 const u32 pw_len = device_param->pws_buf[i].pw_len;
2760
2761 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2762
2763 ptr[pw_len] = 0x01;
2764 }
2765 }
2766 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2767 {
2768 for (u32 i = 0; i < pws_cnt; i++)
2769 {
2770 const u32 pw_len = device_param->pws_buf[i].pw_len;
2771
2772 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2773
2774 ptr[pw_len] = 0x80;
2775 }
2776 }
2777 }
2778
2779 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);
2780 }
2781 else if (data.attack_kern == ATTACK_KERN_BF)
2782 {
2783 const u64 off = device_param->words_off;
2784
2785 device_param->kernel_params_mp_l_buf64[3] = off;
2786
2787 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2788 }
2789 }
2790
2791 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2792 {
2793 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2794
2795 device_param->kernel_params_buf32[26] = kernel_loops;
2796 device_param->kernel_params_buf32[27] = kernel_loops;
2797
2798 // init some fake words
2799
2800 for (u32 i = 0; i < kernel_power; i++)
2801 {
2802 device_param->pws_buf[i].i[0] = i;
2803 device_param->pws_buf[i].i[1] = 0x01234567;
2804 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2805 }
2806
2807 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);
2808
2809 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2810 {
2811 run_kernel_amp (device_param, kernel_power);
2812 }
2813
2814 // caching run
2815
2816 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2817 {
2818 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2819 }
2820 else
2821 {
2822 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2823 }
2824
2825 // now user repeats
2826
2827 for (int i = 0; i < repeat; i++)
2828 {
2829 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2830 {
2831 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2832 }
2833 else
2834 {
2835 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2836 }
2837 }
2838
2839 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2840
2841 // reset fake words
2842
2843 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2844
2845 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);
2846 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);
2847
2848 return exec_ms_prev;
2849 }
2850
2851 static void autotune (hc_device_param_t *device_param)
2852 {
2853 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2854
2855 const u32 kernel_accel_min = device_param->kernel_accel_min;
2856 const u32 kernel_accel_max = device_param->kernel_accel_max;
2857
2858 const u32 kernel_loops_min = device_param->kernel_loops_min;
2859 const u32 kernel_loops_max = device_param->kernel_loops_max;
2860
2861 u32 kernel_accel = kernel_accel_min;
2862 u32 kernel_loops = kernel_loops_min;
2863
2864 // steps
2865
2866 #define STEPS_CNT 10
2867
2868 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2869 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2870
2871 u32 steps_accel[STEPS_ACCEL_CNT];
2872 u32 steps_loops[STEPS_LOOPS_CNT];
2873
2874 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2875 {
2876 steps_accel[i] = 1 << i;
2877 }
2878
2879 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2880 {
2881 steps_loops[i] = 1 << i;
2882 }
2883
2884 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2885 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2886
2887 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2888 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2889
2890 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2891 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2892
2893 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2894
2895 u32 kernel_loops_tmp;
2896
2897 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2898 {
2899 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2900
2901 if (exec_ms < target_ms) break;
2902 }
2903
2904 // kernel-accel
2905
2906 if (kernel_accel_min < kernel_accel_max)
2907 {
2908 double e_best = 0;
2909
2910 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2911 {
2912 const u32 kernel_accel_try = steps_accel[i];
2913
2914 if (kernel_accel_try < kernel_accel_min) continue;
2915 if (kernel_accel_try > kernel_accel_max) break;
2916
2917 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2918
2919 if (exec_ms > target_ms) break;
2920
2921 const double e = kernel_accel_try / exec_ms;
2922
2923 if (e > e_best)
2924 {
2925 kernel_accel = kernel_accel_try;
2926
2927 e_best = e;
2928 }
2929 }
2930 }
2931
2932 // kernel-loops final
2933
2934 if (kernel_loops_min < kernel_loops_max)
2935 {
2936 double e_best = 0;
2937
2938 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2939 {
2940 const u32 kernel_loops_try = steps_loops[i];
2941
2942 if (kernel_loops_try < kernel_loops_min) continue;
2943 if (kernel_loops_try > kernel_loops_max) break;
2944
2945 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2946
2947 if (exec_ms > target_ms) break;
2948
2949 const double e = kernel_loops_try / exec_ms;
2950
2951 if (e > e_best)
2952 {
2953 kernel_loops = kernel_loops_try;
2954
2955 e_best = e;
2956 }
2957 }
2958 }
2959
2960 // final balance
2961
2962 u32 kernel_accel_best = kernel_accel;
2963 u32 kernel_loops_best = kernel_loops;
2964
2965 u32 exec_best = -1;
2966
2967 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2968 {
2969 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2970
2971 exec_best = exec_ms;
2972 }
2973
2974 // reset
2975
2976 if (kernel_accel_min < kernel_accel_max)
2977 {
2978 u32 kernel_accel_try = kernel_accel;
2979 u32 kernel_loops_try = kernel_loops;
2980
2981 for (int i = 0; i < 2; i++)
2982 {
2983 kernel_accel_try >>= 1;
2984 kernel_loops_try <<= 1;
2985
2986 if (kernel_accel_try < kernel_accel_min) break;
2987 if (kernel_loops_try > kernel_loops_max) break;
2988
2989 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2990
2991 if (exec_ms < exec_best)
2992 {
2993 kernel_accel_best = kernel_accel_try;
2994 kernel_loops_best = kernel_loops_try;
2995
2996 exec_best = exec_ms;
2997 }
2998 }
2999 }
3000
3001 // reset
3002
3003 if (kernel_loops_min < kernel_loops_max)
3004 {
3005 u32 kernel_accel_try = kernel_accel;
3006 u32 kernel_loops_try = kernel_loops;
3007
3008 for (int i = 0; i < 2; i++)
3009 {
3010 kernel_accel_try <<= 1;
3011 kernel_loops_try >>= 1;
3012
3013 if (kernel_accel_try > kernel_accel_max) break;
3014 if (kernel_loops_try < kernel_loops_min) break;
3015
3016 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3017
3018 if (exec_ms < exec_best)
3019 {
3020 kernel_accel_best = kernel_accel_try;
3021 kernel_loops_best = kernel_loops_try;
3022
3023 exec_best = exec_ms;
3024 }
3025 }
3026 }
3027
3028 // because of the balance we may have some free space left!
3029
3030 const int exec_left = target_ms / exec_best;
3031
3032 const int accel_left = kernel_accel_max / kernel_accel_best;
3033
3034 const int exec_accel_min = MIN (exec_left, accel_left);
3035
3036 if (exec_accel_min)
3037 {
3038 kernel_accel_best *= exec_accel_min;
3039 }
3040
3041 // reset timer
3042
3043 device_param->exec_pos = 0;
3044
3045 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3046
3047 // store
3048
3049 kernel_accel = kernel_accel_best;
3050 kernel_loops = kernel_loops_best;
3051
3052 device_param->kernel_accel = kernel_accel;
3053 device_param->kernel_loops = kernel_loops;
3054
3055 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3056
3057 device_param->kernel_power = kernel_power;
3058
3059 #ifdef DEBUG
3060
3061 if (data.quiet == 0)
3062 {
3063 clear_prompt ();
3064
3065 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3066 "Device #%u: autotuned kernel-loops to %u\n",
3067 device_param->device_id + 1,
3068 kernel_accel,
3069 device_param->device_id + 1,
3070 kernel_loops);
3071
3072 fprintf (stdout, "%s", PROMPT);
3073 fflush (stdout);
3074 }
3075
3076 #endif
3077 }
3078
3079 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3080 {
3081 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3082
3083 // init speed timer
3084
3085 uint speed_pos = device_param->speed_pos;
3086
3087 #ifdef _POSIX
3088 if (device_param->timer_speed.tv_sec == 0)
3089 {
3090 hc_timer_set (&device_param->timer_speed);
3091 }
3092 #endif
3093
3094 #ifdef _WIN
3095 if (device_param->timer_speed.QuadPart == 0)
3096 {
3097 hc_timer_set (&device_param->timer_speed);
3098 }
3099 #endif
3100
3101 // find higest password length, this is for optimization stuff
3102
3103 uint highest_pw_len = 0;
3104
3105 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3106 {
3107 }
3108 else if (data.attack_kern == ATTACK_KERN_COMBI)
3109 {
3110 }
3111 else if (data.attack_kern == ATTACK_KERN_BF)
3112 {
3113 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3114 + device_param->kernel_params_mp_l_buf32[5];
3115 }
3116
3117 // iteration type
3118
3119 uint innerloop_step = 0;
3120 uint innerloop_cnt = 0;
3121
3122 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3123 else innerloop_step = 1;
3124
3125 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3126 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3127 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3128
3129 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3130
3131 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3132 {
3133 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3134
3135 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3136
3137 if (data.devices_status == STATUS_CRACKED) break;
3138 if (data.devices_status == STATUS_ABORTED) break;
3139 if (data.devices_status == STATUS_QUIT) break;
3140 if (data.devices_status == STATUS_BYPASS) break;
3141
3142 salt_t *salt_buf = &data.salts_buf[salt_pos];
3143
3144 device_param->kernel_params_buf32[24] = salt_pos;
3145 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3146 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3147
3148 FILE *combs_fp = device_param->combs_fp;
3149
3150 if (data.attack_mode == ATTACK_MODE_COMBI)
3151 {
3152 rewind (combs_fp);
3153 }
3154
3155 // innerloops
3156
3157 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3158 {
3159 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3160
3161 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3162
3163 if (data.devices_status == STATUS_CRACKED) break;
3164 if (data.devices_status == STATUS_ABORTED) break;
3165 if (data.devices_status == STATUS_QUIT) break;
3166 if (data.devices_status == STATUS_BYPASS) break;
3167
3168 uint innerloop_left = innerloop_cnt - innerloop_pos;
3169
3170 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3171
3172 device_param->innerloop_pos = innerloop_pos;
3173 device_param->innerloop_left = innerloop_left;
3174
3175 device_param->kernel_params_buf32[27] = innerloop_left;
3176
3177 // i think we can get rid of this
3178 if (innerloop_left == 0)
3179 {
3180 puts ("bug, how should this happen????\n");
3181
3182 continue;
3183 }
3184
3185 if (data.salts_shown[salt_pos] == 1)
3186 {
3187 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3188
3189 continue;
3190 }
3191
3192 // initialize amplifiers
3193
3194 if (data.attack_mode == ATTACK_MODE_COMBI)
3195 {
3196 uint i = 0;
3197
3198 while (i < innerloop_left)
3199 {
3200 if (feof (combs_fp)) break;
3201
3202 int line_len = fgetl (combs_fp, line_buf);
3203
3204 if (line_len >= PW_MAX1) continue;
3205
3206 line_len = convert_from_hex (line_buf, line_len);
3207
3208 char *line_buf_new = line_buf;
3209
3210 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3211 {
3212 char rule_buf_out[BLOCK_SIZE] = { 0 };
3213
3214 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3215
3216 if (rule_len_out < 0)
3217 {
3218 data.words_progress_rejected[salt_pos] += pws_cnt;
3219
3220 continue;
3221 }
3222
3223 line_len = rule_len_out;
3224
3225 line_buf_new = rule_buf_out;
3226 }
3227
3228 line_len = MIN (line_len, PW_DICTMAX);
3229
3230 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3231
3232 memcpy (ptr, line_buf_new, line_len);
3233
3234 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3235
3236 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3237 {
3238 uppercase (ptr, line_len);
3239 }
3240
3241 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3242 {
3243 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3244 {
3245 ptr[line_len] = 0x80;
3246 }
3247
3248 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3249 {
3250 ptr[line_len] = 0x01;
3251 }
3252 }
3253
3254 device_param->combs_buf[i].pw_len = line_len;
3255
3256 i++;
3257 }
3258
3259 for (uint j = i; j < innerloop_left; j++)
3260 {
3261 device_param->combs_buf[j].i[0] = 0;
3262 device_param->combs_buf[j].i[1] = 0;
3263 device_param->combs_buf[j].i[2] = 0;
3264 device_param->combs_buf[j].i[3] = 0;
3265 device_param->combs_buf[j].i[4] = 0;
3266 device_param->combs_buf[j].i[5] = 0;
3267 device_param->combs_buf[j].i[6] = 0;
3268 device_param->combs_buf[j].i[7] = 0;
3269
3270 device_param->combs_buf[j].pw_len = 0;
3271 }
3272
3273 innerloop_left = i;
3274 }
3275 else if (data.attack_mode == ATTACK_MODE_BF)
3276 {
3277 u64 off = innerloop_pos;
3278
3279 device_param->kernel_params_mp_r_buf64[3] = off;
3280
3281 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3282 }
3283 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3284 {
3285 u64 off = innerloop_pos;
3286
3287 device_param->kernel_params_mp_buf64[3] = off;
3288
3289 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3290 }
3291 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3292 {
3293 u64 off = innerloop_pos;
3294
3295 device_param->kernel_params_mp_buf64[3] = off;
3296
3297 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3298 }
3299
3300 // copy amplifiers
3301
3302 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3303 {
3304 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);
3305 }
3306 else if (data.attack_mode == ATTACK_MODE_COMBI)
3307 {
3308 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);
3309 }
3310 else if (data.attack_mode == ATTACK_MODE_BF)
3311 {
3312 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);
3313 }
3314 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3315 {
3316 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);
3317 }
3318 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3319 {
3320 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);
3321 }
3322
3323 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3324
3325 if (data.benchmark == 1)
3326 {
3327 double exec_ms_avg_prev = get_avg_exec_time (device_param, EXEC_CACHE);
3328
3329 // a few caching rounds
3330
3331 for (u32 i = 0; i < 2; i++)
3332 {
3333 hc_timer_set (&device_param->timer_speed);
3334
3335 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3336
3337 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
3338
3339 exec_ms_avg_prev = exec_ms_avg;
3340 }
3341
3342 // benchmark_repeats became a maximum possible repeats
3343
3344 for (u32 i = 2; i < data.benchmark_repeats; i++)
3345 {
3346 hc_timer_set (&device_param->timer_speed);
3347
3348 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3349
3350 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
3351
3352 if ((exec_ms_avg_prev / exec_ms_avg) < 1.001) break;
3353
3354 exec_ms_avg_prev = exec_ms_avg;
3355 }
3356 }
3357
3358 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3359
3360 if (data.devices_status == STATUS_CRACKED) break;
3361 if (data.devices_status == STATUS_ABORTED) break;
3362 if (data.devices_status == STATUS_QUIT) break;
3363
3364 /**
3365 * result
3366 */
3367
3368 hc_thread_mutex_lock (mux_display);
3369
3370 check_cracked (device_param, salt_pos);
3371
3372 hc_thread_mutex_unlock (mux_display);
3373
3374 /**
3375 * progress
3376 */
3377
3378 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3379
3380 hc_thread_mutex_lock (mux_counter);
3381
3382 data.words_progress_done[salt_pos] += perf_sum_all;
3383
3384 hc_thread_mutex_unlock (mux_counter);
3385
3386 /**
3387 * speed
3388 */
3389
3390 double speed_ms;
3391
3392 hc_timer_get (device_param->timer_speed, speed_ms);
3393
3394 hc_timer_set (&device_param->timer_speed);
3395
3396 hc_thread_mutex_lock (mux_display);
3397
3398 // current speed
3399
3400 device_param->speed_cnt[speed_pos] = perf_sum_all;
3401
3402 device_param->speed_ms[speed_pos] = speed_ms;
3403
3404 hc_thread_mutex_unlock (mux_display);
3405
3406 speed_pos++;
3407
3408 if (speed_pos == SPEED_CACHE)
3409 {
3410 speed_pos = 0;
3411 }
3412
3413 /**
3414 * benchmark
3415 */
3416
3417 if (data.benchmark == 1) break;
3418 }
3419 }
3420
3421 device_param->speed_pos = speed_pos;
3422
3423 myfree (line_buf);
3424 }
3425
3426 static void load_segment (wl_data_t *wl_data, FILE *fd)
3427 {
3428 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3429
3430 wl_data->pos = 0;
3431
3432 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3433
3434 wl_data->buf[wl_data->cnt] = 0;
3435
3436 if (wl_data->cnt == 0) return;
3437
3438 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3439
3440 while (!feof (fd))
3441 {
3442 if (wl_data->cnt == wl_data->avail)
3443 {
3444 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3445
3446 wl_data->avail += wl_data->incr;
3447 }
3448
3449 const int c = fgetc (fd);
3450
3451 if (c == EOF) break;
3452
3453 wl_data->buf[wl_data->cnt] = (char) c;
3454
3455 wl_data->cnt++;
3456
3457 if (c == '\n') break;
3458 }
3459
3460 // ensure stream ends with a newline
3461
3462 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3463 {
3464 wl_data->cnt++;
3465
3466 wl_data->buf[wl_data->cnt - 1] = '\n';
3467 }
3468
3469 return;
3470 }
3471
3472 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3473 {
3474 char *ptr = buf;
3475
3476 for (u32 i = 0; i < sz; i++, ptr++)
3477 {
3478 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3479
3480 if (i == 7)
3481 {
3482 *off = i;
3483 *len = i;
3484
3485 return;
3486 }
3487
3488 if (*ptr != '\n') continue;
3489
3490 *off = i + 1;
3491
3492 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3493
3494 *len = i;
3495
3496 return;
3497 }
3498
3499 *off = sz;
3500 *len = sz;
3501 }
3502
3503 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3504 {
3505 char *ptr = buf;
3506
3507 for (u32 i = 0; i < sz; i++, ptr++)
3508 {
3509 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3510
3511 if (*ptr != '\n') continue;
3512
3513 *off = i + 1;
3514
3515 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3516
3517 *len = i;
3518
3519 return;
3520 }
3521
3522 *off = sz;
3523 *len = sz;
3524 }
3525
3526 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3527 {
3528 char *ptr = buf;
3529
3530 for (u32 i = 0; i < sz; i++, ptr++)
3531 {
3532 if (*ptr != '\n') continue;
3533
3534 *off = i + 1;
3535
3536 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3537
3538 *len = i;
3539
3540 return;
3541 }
3542
3543 *off = sz;
3544 *len = sz;
3545 }
3546
3547 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3548 {
3549 while (wl_data->pos < wl_data->cnt)
3550 {
3551 uint off;
3552 uint len;
3553
3554 char *ptr = wl_data->buf + wl_data->pos;
3555
3556 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3557
3558 wl_data->pos += off;
3559
3560 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3561 {
3562 char rule_buf_out[BLOCK_SIZE] = { 0 };
3563
3564 int rule_len_out = -1;
3565
3566 if (len < BLOCK_SIZE)
3567 {
3568 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3569 }
3570
3571 if (rule_len_out < 0)
3572 {
3573 continue;
3574 }
3575
3576 if (rule_len_out > PW_MAX)
3577 {
3578 continue;
3579 }
3580 }
3581 else
3582 {
3583 if (len > PW_MAX)
3584 {
3585 continue;
3586 }
3587 }
3588
3589 *out_buf = ptr;
3590 *out_len = len;
3591
3592 return;
3593 }
3594
3595 if (feof (fd))
3596 {
3597 fprintf (stderr, "BUG feof()!!\n");
3598
3599 return;
3600 }
3601
3602 load_segment (wl_data, fd);
3603
3604 get_next_word (wl_data, fd, out_buf, out_len);
3605 }
3606
3607 #ifdef _POSIX
3608 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3609 #endif
3610
3611 #ifdef _WIN
3612 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3613 #endif
3614 {
3615 hc_signal (NULL);
3616
3617 dictstat_t d;
3618
3619 d.cnt = 0;
3620
3621 #ifdef _POSIX
3622 fstat (fileno (fd), &d.stat);
3623 #endif
3624
3625 #ifdef _WIN
3626 _fstat64 (fileno (fd), &d.stat);
3627 #endif
3628
3629 d.stat.st_mode = 0;
3630 d.stat.st_nlink = 0;
3631 d.stat.st_uid = 0;
3632 d.stat.st_gid = 0;
3633 d.stat.st_rdev = 0;
3634 d.stat.st_atime = 0;
3635
3636 #ifdef _POSIX
3637 d.stat.st_blksize = 0;
3638 d.stat.st_blocks = 0;
3639 #endif
3640
3641 if (d.stat.st_size == 0) return 0;
3642
3643 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3644
3645 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3646 {
3647 if (d_cache)
3648 {
3649 u64 cnt = d_cache->cnt;
3650
3651 u64 keyspace = cnt;
3652
3653 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3654 {
3655 keyspace *= data.kernel_rules_cnt;
3656 }
3657 else if (data.attack_kern == ATTACK_KERN_COMBI)
3658 {
3659 keyspace *= data.combs_cnt;
3660 }
3661
3662 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);
3663 if (data.quiet == 0) log_info ("");
3664
3665 hc_signal (sigHandler_default);
3666
3667 return (keyspace);
3668 }
3669 }
3670
3671 time_t now = 0;
3672 time_t prev = 0;
3673
3674 u64 comp = 0;
3675 u64 cnt = 0;
3676 u64 cnt2 = 0;
3677
3678 while (!feof (fd))
3679 {
3680 load_segment (wl_data, fd);
3681
3682 comp += wl_data->cnt;
3683
3684 u32 i = 0;
3685
3686 while (i < wl_data->cnt)
3687 {
3688 u32 len;
3689 u32 off;
3690
3691 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3692
3693 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3694 {
3695 char rule_buf_out[BLOCK_SIZE] = { 0 };
3696
3697 int rule_len_out = -1;
3698
3699 if (len < BLOCK_SIZE)
3700 {
3701 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3702 }
3703
3704 if (rule_len_out < 0)
3705 {
3706 len = PW_MAX1;
3707 }
3708 else
3709 {
3710 len = rule_len_out;
3711 }
3712 }
3713
3714 if (len < PW_MAX1)
3715 {
3716 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3717 {
3718 cnt += data.kernel_rules_cnt;
3719 }
3720 else if (data.attack_kern == ATTACK_KERN_COMBI)
3721 {
3722 cnt += data.combs_cnt;
3723 }
3724
3725 d.cnt++;
3726 }
3727
3728 i += off;
3729
3730 cnt2++;
3731 }
3732
3733 time (&now);
3734
3735 if ((now - prev) == 0) continue;
3736
3737 float percent = (float) comp / (float) d.stat.st_size;
3738
3739 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);
3740
3741 time (&prev);
3742 }
3743
3744 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);
3745 if (data.quiet == 0) log_info ("");
3746
3747 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3748
3749 hc_signal (sigHandler_default);
3750
3751 return (cnt);
3752 }
3753
3754 static void *thread_monitor (void *p)
3755 {
3756 uint runtime_check = 0;
3757 uint remove_check = 0;
3758 uint status_check = 0;
3759 uint restore_check = 0;
3760
3761 uint restore_left = data.restore_timer;
3762 uint remove_left = data.remove_timer;
3763 uint status_left = data.status_timer;
3764
3765 #ifdef HAVE_HWMON
3766 uint hwmon_check = 0;
3767
3768 // these variables are mainly used for fan control (AMD only)
3769
3770 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3771
3772 // temperature controller "loopback" values
3773
3774 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3775 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3776
3777 #ifdef HAVE_ADL
3778 int temp_threshold = 1; // degrees celcius
3779
3780 int fan_speed_min = 15; // in percentage
3781 int fan_speed_max = 100;
3782 #endif // HAVE_ADL
3783
3784 time_t last_temp_check_time;
3785 #endif // HAVE_HWMON
3786
3787 uint sleep_time = 1;
3788
3789 if (data.runtime)
3790 {
3791 runtime_check = 1;
3792 }
3793
3794 if (data.restore_timer)
3795 {
3796 restore_check = 1;
3797 }
3798
3799 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3800 {
3801 remove_check = 1;
3802 }
3803
3804 if (data.status == 1)
3805 {
3806 status_check = 1;
3807 }
3808
3809 #ifdef HAVE_HWMON
3810 if (data.gpu_temp_disable == 0)
3811 {
3812 time (&last_temp_check_time);
3813
3814 hwmon_check = 1;
3815 }
3816 #endif
3817
3818 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3819 {
3820 #ifdef HAVE_HWMON
3821 if (hwmon_check == 0)
3822 #endif
3823 return (p);
3824 }
3825
3826 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3827 {
3828 hc_sleep (sleep_time);
3829
3830 if (data.devices_status != STATUS_RUNNING) continue;
3831
3832 #ifdef HAVE_HWMON
3833 if (hwmon_check == 1)
3834 {
3835 hc_thread_mutex_lock (mux_adl);
3836
3837 time_t temp_check_time;
3838
3839 time (&temp_check_time);
3840
3841 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3842
3843 if (Ta == 0) Ta = 1;
3844
3845 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3846 {
3847 hc_device_param_t *device_param = &data.devices_param[device_id];
3848
3849 if (device_param->skipped) continue;
3850
3851 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3852
3853 const int temperature = hm_get_temperature_with_device_id (device_id);
3854
3855 if (temperature > (int) data.gpu_temp_abort)
3856 {
3857 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3858
3859 if (data.devices_status != STATUS_QUIT) myabort ();
3860
3861 break;
3862 }
3863
3864 #ifdef HAVE_ADL
3865 const int gpu_temp_retain = data.gpu_temp_retain;
3866
3867 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3868 {
3869 if (data.hm_device[device_id].fan_supported == 1)
3870 {
3871 int temp_cur = temperature;
3872
3873 int temp_diff_new = gpu_temp_retain - temp_cur;
3874
3875 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3876
3877 // calculate Ta value (time difference in seconds between the last check and this check)
3878
3879 last_temp_check_time = temp_check_time;
3880
3881 float Kp = 1.8;
3882 float Ki = 0.005;
3883 float Kd = 6;
3884
3885 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3886
3887 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);
3888
3889 if (abs (fan_diff_required) >= temp_threshold)
3890 {
3891 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3892
3893 int fan_speed_level = fan_speed_cur;
3894
3895 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3896
3897 int fan_speed_new = fan_speed_level - fan_diff_required;
3898
3899 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3900 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3901
3902 if (fan_speed_new != fan_speed_cur)
3903 {
3904 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3905 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3906
3907 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3908 {
3909 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3910
3911 fan_speed_chgd[device_id] = 1;
3912 }
3913
3914 temp_diff_old[device_id] = temp_diff_new;
3915 }
3916 }
3917 }
3918 }
3919 #endif // HAVE_ADL
3920 }
3921
3922 hc_thread_mutex_unlock (mux_adl);
3923 }
3924 #endif // HAVE_HWMON
3925
3926 if (restore_check == 1)
3927 {
3928 restore_left--;
3929
3930 if (restore_left == 0)
3931 {
3932 if (data.restore_disable == 0) cycle_restore ();
3933
3934 restore_left = data.restore_timer;
3935 }
3936 }
3937
3938 if ((runtime_check == 1) && (data.runtime_start > 0))
3939 {
3940 time_t runtime_cur;
3941
3942 time (&runtime_cur);
3943
3944 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3945
3946 if (runtime_left <= 0)
3947 {
3948 if (data.benchmark == 0)
3949 {
3950 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3951 }
3952
3953 if (data.devices_status != STATUS_QUIT) myabort ();
3954 }
3955 }
3956
3957 if (remove_check == 1)
3958 {
3959 remove_left--;
3960
3961 if (remove_left == 0)
3962 {
3963 if (data.digests_saved != data.digests_done)
3964 {
3965 data.digests_saved = data.digests_done;
3966
3967 save_hash ();
3968 }
3969
3970 remove_left = data.remove_timer;
3971 }
3972 }
3973
3974 if (status_check == 1)
3975 {
3976 status_left--;
3977
3978 if (status_left == 0)
3979 {
3980 hc_thread_mutex_lock (mux_display);
3981
3982 if (data.quiet == 0) clear_prompt ();
3983
3984 if (data.quiet == 0) log_info ("");
3985
3986 status_display ();
3987
3988 if (data.quiet == 0) log_info ("");
3989
3990 hc_thread_mutex_unlock (mux_display);
3991
3992 status_left = data.status_timer;
3993 }
3994 }
3995 }
3996
3997 #ifdef HAVE_HWMON
3998 myfree (fan_speed_chgd);
3999
4000 myfree (temp_diff_old);
4001 myfree (temp_diff_sum);
4002 #endif
4003
4004 p = NULL;
4005
4006 return (p);
4007 }
4008
4009 static void *thread_outfile_remove (void *p)
4010 {
4011 // some hash-dependent constants
4012 char *outfile_dir = data.outfile_check_directory;
4013 uint dgst_size = data.dgst_size;
4014 uint isSalted = data.isSalted;
4015 uint esalt_size = data.esalt_size;
4016 uint hash_mode = data.hash_mode;
4017
4018 uint outfile_check_timer = data.outfile_check_timer;
4019
4020 char separator = data.separator;
4021
4022 // some hash-dependent functions
4023 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4024 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4025
4026 // buffers
4027 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4028
4029 hash_buf.digest = mymalloc (dgst_size);
4030
4031 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4032
4033 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4034
4035 uint digest_buf[64] = { 0 };
4036
4037 outfile_data_t *out_info = NULL;
4038
4039 char **out_files = NULL;
4040
4041 time_t folder_mtime = 0;
4042
4043 int out_cnt = 0;
4044
4045 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4046
4047 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4048 {
4049 hc_sleep (1);
4050
4051 if (data.devices_status != STATUS_RUNNING) continue;
4052
4053 check_left--;
4054
4055 if (check_left == 0)
4056 {
4057 struct stat outfile_check_stat;
4058
4059 if (stat (outfile_dir, &outfile_check_stat) == 0)
4060 {
4061 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4062
4063 if (is_dir == 1)
4064 {
4065 if (outfile_check_stat.st_mtime > folder_mtime)
4066 {
4067 char **out_files_new = scan_directory (outfile_dir);
4068
4069 int out_cnt_new = count_dictionaries (out_files_new);
4070
4071 outfile_data_t *out_info_new = NULL;
4072
4073 if (out_cnt_new > 0)
4074 {
4075 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4076
4077 for (int i = 0; i < out_cnt_new; i++)
4078 {
4079 out_info_new[i].file_name = out_files_new[i];
4080
4081 // check if there are files that we have seen/checked before (and not changed)
4082
4083 for (int j = 0; j < out_cnt; j++)
4084 {
4085 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4086 {
4087 struct stat outfile_stat;
4088
4089 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4090 {
4091 if (outfile_stat.st_ctime == out_info[j].ctime)
4092 {
4093 out_info_new[i].ctime = out_info[j].ctime;
4094 out_info_new[i].seek = out_info[j].seek;
4095 }
4096 }
4097 }
4098 }
4099 }
4100 }
4101
4102 local_free (out_info);
4103 local_free (out_files);
4104
4105 out_files = out_files_new;
4106 out_cnt = out_cnt_new;
4107 out_info = out_info_new;
4108
4109 folder_mtime = outfile_check_stat.st_mtime;
4110 }
4111
4112 for (int j = 0; j < out_cnt; j++)
4113 {
4114 FILE *fp = fopen (out_info[j].file_name, "rb");
4115
4116 if (fp != NULL)
4117 {
4118 //hc_thread_mutex_lock (mux_display);
4119
4120 #ifdef _POSIX
4121 struct stat outfile_stat;
4122
4123 fstat (fileno (fp), &outfile_stat);
4124 #endif
4125
4126 #ifdef _WIN
4127 struct stat64 outfile_stat;
4128
4129 _fstat64 (fileno (fp), &outfile_stat);
4130 #endif
4131
4132 if (outfile_stat.st_ctime > out_info[j].ctime)
4133 {
4134 out_info[j].ctime = outfile_stat.st_ctime;
4135 out_info[j].seek = 0;
4136 }
4137
4138 fseek (fp, out_info[j].seek, SEEK_SET);
4139
4140 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4141
4142 while (!feof (fp))
4143 {
4144 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4145
4146 if (ptr == NULL) break;
4147
4148 int line_len = strlen (line_buf);
4149
4150 if (line_len <= 0) continue;
4151
4152 int iter = MAX_CUT_TRIES;
4153
4154 for (uint i = line_len - 1; i && iter; i--, line_len--)
4155 {
4156 if (line_buf[i] != separator) continue;
4157
4158 int parser_status = PARSER_OK;
4159
4160 if ((hash_mode != 2500) && (hash_mode != 6800))
4161 {
4162 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4163 }
4164
4165 uint found = 0;
4166
4167 if (parser_status == PARSER_OK)
4168 {
4169 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4170 {
4171 if (data.salts_shown[salt_pos] == 1) continue;
4172
4173 salt_t *salt_buf = &data.salts_buf[salt_pos];
4174
4175 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4176 {
4177 uint idx = salt_buf->digests_offset + digest_pos;
4178
4179 if (data.digests_shown[idx] == 1) continue;
4180
4181 uint cracked = 0;
4182
4183 if (hash_mode == 6800)
4184 {
4185 if (i == salt_buf->salt_len)
4186 {
4187 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4188 }
4189 }
4190 else if (hash_mode == 2500)
4191 {
4192 // BSSID : MAC1 : MAC2 (:plain)
4193 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4194 {
4195 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4196
4197 if (!cracked) continue;
4198
4199 // now compare MAC1 and MAC2 too, since we have this additional info
4200 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4201 char *mac2_pos = mac1_pos + 12 + 1;
4202
4203 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4204 wpa_t *wpa = &wpas[salt_pos];
4205
4206 // compare hex string(s) vs binary MAC address(es)
4207
4208 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4209 {
4210 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4211 {
4212 cracked = 0;
4213
4214 break;
4215 }
4216 }
4217
4218 // early skip ;)
4219 if (!cracked) continue;
4220
4221 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4222 {
4223 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4224 {
4225 cracked = 0;
4226
4227 break;
4228 }
4229 }
4230 }
4231 }
4232 else
4233 {
4234 char *digests_buf_ptr = (char *) data.digests_buf;
4235
4236 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4237
4238 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4239 }
4240
4241 if (cracked == 1)
4242 {
4243 found = 1;
4244
4245 data.digests_shown[idx] = 1;
4246
4247 data.digests_done++;
4248
4249 salt_buf->digests_done++;
4250
4251 if (salt_buf->digests_done == salt_buf->digests_cnt)
4252 {
4253 data.salts_shown[salt_pos] = 1;
4254
4255 data.salts_done++;
4256
4257 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4258 }
4259 }
4260 }
4261
4262 if (data.devices_status == STATUS_CRACKED) break;
4263 }
4264 }
4265
4266 if (found) break;
4267
4268 if (data.devices_status == STATUS_CRACKED) break;
4269
4270 iter--;
4271 }
4272
4273 if (data.devices_status == STATUS_CRACKED) break;
4274 }
4275
4276 myfree (line_buf);
4277
4278 out_info[j].seek = ftell (fp);
4279
4280 //hc_thread_mutex_unlock (mux_display);
4281
4282 fclose (fp);
4283 }
4284 }
4285 }
4286 }
4287
4288 check_left = outfile_check_timer;
4289 }
4290 }
4291
4292 if (esalt_size) local_free (hash_buf.esalt);
4293
4294 if (isSalted) local_free (hash_buf.salt);
4295
4296 local_free (hash_buf.digest);
4297
4298 local_free (out_info);
4299
4300 local_free (out_files);
4301
4302 p = NULL;
4303
4304 return (p);
4305 }
4306
4307 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4308 {
4309 if (device_param->pws_cnt < device_param->kernel_power)
4310 {
4311 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4312
4313 u8 *ptr = (u8 *) pw->i;
4314
4315 memcpy (ptr, pw_buf, pw_len);
4316
4317 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4318
4319 pw->pw_len = pw_len;
4320
4321 device_param->pws_cnt++;
4322 }
4323 else
4324 {
4325 fprintf (stderr, "BUG pw_add()!!\n");
4326
4327 return;
4328 }
4329 }
4330
4331 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4332 {
4333 hc_thread_mutex_lock (mux_dispatcher);
4334
4335 const u64 words_cur = data.words_cur;
4336 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4337
4338 device_param->words_off = words_cur;
4339
4340 const u64 words_left = words_base - words_cur;
4341
4342 if (allow_div)
4343 {
4344 if (data.kernel_power_all > words_left)
4345 {
4346 if (data.kernel_power_div == 0)
4347 {
4348 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4349 }
4350 }
4351
4352 if (data.kernel_power_div)
4353 {
4354 if (device_param->kernel_power == device_param->kernel_power_user)
4355 {
4356 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4357
4358 if (kernel_power_new < device_param->kernel_power)
4359 {
4360 device_param->kernel_power = kernel_power_new;
4361 }
4362 }
4363 }
4364 }
4365
4366 const uint kernel_power = device_param->kernel_power;
4367
4368 uint work = MIN (words_left, kernel_power);
4369
4370 work = MIN (work, max);
4371
4372 data.words_cur += work;
4373
4374 hc_thread_mutex_unlock (mux_dispatcher);
4375
4376 return work;
4377 }
4378
4379 static void *thread_calc_stdin (void *p)
4380 {
4381 hc_device_param_t *device_param = (hc_device_param_t *) p;
4382
4383 if (device_param->skipped) return NULL;
4384
4385 autotune (device_param);
4386
4387 char *buf = (char *) mymalloc (HCBUFSIZ);
4388
4389 const uint attack_kern = data.attack_kern;
4390
4391 const uint kernel_power = device_param->kernel_power;
4392
4393 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4394 {
4395 hc_thread_mutex_lock (mux_dispatcher);
4396
4397 if (feof (stdin) != 0)
4398 {
4399 hc_thread_mutex_unlock (mux_dispatcher);
4400
4401 break;
4402 }
4403
4404 uint words_cur = 0;
4405
4406 while (words_cur < kernel_power)
4407 {
4408 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4409
4410 if (line_buf == NULL) break;
4411
4412 uint line_len = in_superchop (line_buf);
4413
4414 line_len = convert_from_hex (line_buf, line_len);
4415
4416 // post-process rule engine
4417
4418 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4419 {
4420 char rule_buf_out[BLOCK_SIZE] = { 0 };
4421
4422 int rule_len_out = -1;
4423
4424 if (line_len < BLOCK_SIZE)
4425 {
4426 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4427 }
4428
4429 if (rule_len_out < 0) continue;
4430
4431 line_buf = rule_buf_out;
4432 line_len = rule_len_out;
4433 }
4434
4435 if (line_len > PW_MAX)
4436 {
4437 continue;
4438 }
4439
4440 if (attack_kern == ATTACK_KERN_STRAIGHT)
4441 {
4442 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4443 {
4444 hc_thread_mutex_lock (mux_counter);
4445
4446 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4447 {
4448 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4449 }
4450
4451 hc_thread_mutex_unlock (mux_counter);
4452
4453 continue;
4454 }
4455 }
4456 else if (attack_kern == ATTACK_KERN_COMBI)
4457 {
4458 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4459 // since we still need to combine the plains
4460
4461 if (line_len > data.pw_max)
4462 {
4463 hc_thread_mutex_lock (mux_counter);
4464
4465 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4466 {
4467 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4468 }
4469
4470 hc_thread_mutex_unlock (mux_counter);
4471
4472 continue;
4473 }
4474 }
4475
4476 pw_add (device_param, (u8 *) line_buf, line_len);
4477
4478 words_cur++;
4479
4480 if (data.devices_status == STATUS_CRACKED) break;
4481 if (data.devices_status == STATUS_ABORTED) break;
4482 if (data.devices_status == STATUS_QUIT) break;
4483 if (data.devices_status == STATUS_BYPASS) break;
4484 }
4485
4486 hc_thread_mutex_unlock (mux_dispatcher);
4487
4488 if (data.devices_status == STATUS_CRACKED) break;
4489 if (data.devices_status == STATUS_ABORTED) break;
4490 if (data.devices_status == STATUS_QUIT) break;
4491 if (data.devices_status == STATUS_BYPASS) break;
4492
4493 // flush
4494
4495 const uint pws_cnt = device_param->pws_cnt;
4496
4497 if (pws_cnt)
4498 {
4499 run_copy (device_param, pws_cnt);
4500
4501 run_cracker (device_param, pws_cnt);
4502
4503 device_param->pws_cnt = 0;
4504
4505 if (attack_kern == ATTACK_KERN_STRAIGHT)
4506 {
4507 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4508 }
4509 else if (attack_kern == ATTACK_KERN_COMBI)
4510 {
4511 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4512 }
4513 }
4514 }
4515
4516 device_param->kernel_accel = 0;
4517 device_param->kernel_loops = 0;
4518
4519 myfree (buf);
4520
4521 return NULL;
4522 }
4523
4524 static void *thread_calc (void *p)
4525 {
4526 hc_device_param_t *device_param = (hc_device_param_t *) p;
4527
4528 if (device_param->skipped) return NULL;
4529
4530 autotune (device_param);
4531
4532 const uint attack_mode = data.attack_mode;
4533 const uint attack_kern = data.attack_kern;
4534
4535 if (attack_mode == ATTACK_MODE_BF)
4536 {
4537 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4538 {
4539 const uint work = get_work (device_param, -1, true);
4540
4541 if (work == 0) break;
4542
4543 const u64 words_off = device_param->words_off;
4544 const u64 words_fin = words_off + work;
4545
4546 const uint pws_cnt = work;
4547
4548 device_param->pws_cnt = pws_cnt;
4549
4550 if (pws_cnt)
4551 {
4552 run_copy (device_param, pws_cnt);
4553
4554 run_cracker (device_param, pws_cnt);
4555
4556 device_param->pws_cnt = 0;
4557
4558 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4559 }
4560
4561 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4562
4563 if (data.devices_status == STATUS_CRACKED) break;
4564 if (data.devices_status == STATUS_ABORTED) break;
4565 if (data.devices_status == STATUS_QUIT) break;
4566 if (data.devices_status == STATUS_BYPASS) break;
4567
4568 if (data.benchmark == 1) break;
4569
4570 device_param->words_done = words_fin;
4571 }
4572 }
4573 else
4574 {
4575 const uint segment_size = data.segment_size;
4576
4577 char *dictfile = data.dictfile;
4578
4579 if (attack_mode == ATTACK_MODE_COMBI)
4580 {
4581 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4582 {
4583 dictfile = data.dictfile2;
4584 }
4585 }
4586
4587 FILE *fd = fopen (dictfile, "rb");
4588
4589 if (fd == NULL)
4590 {
4591 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4592
4593 return NULL;
4594 }
4595
4596 if (attack_mode == ATTACK_MODE_COMBI)
4597 {
4598 const uint combs_mode = data.combs_mode;
4599
4600 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4601 {
4602 const char *dictfilec = data.dictfile2;
4603
4604 FILE *combs_fp = fopen (dictfilec, "rb");
4605
4606 if (combs_fp == NULL)
4607 {
4608 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4609
4610 fclose (fd);
4611
4612 return NULL;
4613 }
4614
4615 device_param->combs_fp = combs_fp;
4616 }
4617 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4618 {
4619 const char *dictfilec = data.dictfile;
4620
4621 FILE *combs_fp = fopen (dictfilec, "rb");
4622
4623 if (combs_fp == NULL)
4624 {
4625 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4626
4627 fclose (fd);
4628
4629 return NULL;
4630 }
4631
4632 device_param->combs_fp = combs_fp;
4633 }
4634 }
4635
4636 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4637
4638 wl_data->buf = (char *) mymalloc (segment_size);
4639 wl_data->avail = segment_size;
4640 wl_data->incr = segment_size;
4641 wl_data->cnt = 0;
4642 wl_data->pos = 0;
4643
4644 u64 words_cur = 0;
4645
4646 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4647 {
4648 u64 words_off = 0;
4649 u64 words_fin = 0;
4650
4651 bool allow_div = true;
4652
4653 u64 max = -1;
4654
4655 while (max)
4656 {
4657 const uint work = get_work (device_param, max, allow_div);
4658
4659 allow_div = false;
4660
4661 if (work == 0) break;
4662
4663 words_off = device_param->words_off;
4664 words_fin = words_off + work;
4665
4666 char *line_buf;
4667 uint line_len;
4668
4669 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4670
4671 max = 0;
4672
4673 for ( ; words_cur < words_fin; words_cur++)
4674 {
4675 get_next_word (wl_data, fd, &line_buf, &line_len);
4676
4677 line_len = convert_from_hex (line_buf, line_len);
4678
4679 // post-process rule engine
4680
4681 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4682 {
4683 char rule_buf_out[BLOCK_SIZE] = { 0 };
4684
4685 int rule_len_out = -1;
4686
4687 if (line_len < BLOCK_SIZE)
4688 {
4689 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4690 }
4691
4692 if (rule_len_out < 0) continue;
4693
4694 line_buf = rule_buf_out;
4695 line_len = rule_len_out;
4696 }
4697
4698 if (attack_kern == ATTACK_KERN_STRAIGHT)
4699 {
4700 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4701 {
4702 max++;
4703
4704 hc_thread_mutex_lock (mux_counter);
4705
4706 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4707 {
4708 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4709 }
4710
4711 hc_thread_mutex_unlock (mux_counter);
4712
4713 continue;
4714 }
4715 }
4716 else if (attack_kern == ATTACK_KERN_COMBI)
4717 {
4718 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4719 // since we still need to combine the plains
4720
4721 if (line_len > data.pw_max)
4722 {
4723 max++;
4724
4725 hc_thread_mutex_lock (mux_counter);
4726
4727 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4728 {
4729 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4730 }
4731
4732 hc_thread_mutex_unlock (mux_counter);
4733
4734 continue;
4735 }
4736 }
4737
4738 pw_add (device_param, (u8 *) line_buf, line_len);
4739
4740 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4741
4742 if (data.devices_status == STATUS_CRACKED) break;
4743 if (data.devices_status == STATUS_ABORTED) break;
4744 if (data.devices_status == STATUS_QUIT) break;
4745 if (data.devices_status == STATUS_BYPASS) break;
4746 }
4747
4748 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4749
4750 if (data.devices_status == STATUS_CRACKED) break;
4751 if (data.devices_status == STATUS_ABORTED) break;
4752 if (data.devices_status == STATUS_QUIT) break;
4753 if (data.devices_status == STATUS_BYPASS) break;
4754 }
4755
4756 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4757
4758 if (data.devices_status == STATUS_CRACKED) break;
4759 if (data.devices_status == STATUS_ABORTED) break;
4760 if (data.devices_status == STATUS_QUIT) break;
4761 if (data.devices_status == STATUS_BYPASS) break;
4762
4763 //
4764 // flush
4765 //
4766
4767 const uint pws_cnt = device_param->pws_cnt;
4768
4769 if (pws_cnt)
4770 {
4771 run_copy (device_param, pws_cnt);
4772
4773 run_cracker (device_param, pws_cnt);
4774
4775 device_param->pws_cnt = 0;
4776
4777 if (attack_kern == ATTACK_KERN_STRAIGHT)
4778 {
4779 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4780 }
4781 else if (attack_kern == ATTACK_KERN_COMBI)
4782 {
4783 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4784 }
4785 }
4786
4787 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4788
4789 if (data.devices_status == STATUS_CRACKED) break;
4790 if (data.devices_status == STATUS_ABORTED) break;
4791 if (data.devices_status == STATUS_QUIT) break;
4792 if (data.devices_status == STATUS_BYPASS) break;
4793
4794 if (words_fin == 0) break;
4795
4796 device_param->words_done = words_fin;
4797 }
4798
4799 if (attack_mode == ATTACK_MODE_COMBI)
4800 {
4801 fclose (device_param->combs_fp);
4802 }
4803
4804 free (wl_data->buf);
4805 free (wl_data);
4806
4807 fclose (fd);
4808 }
4809
4810 device_param->kernel_accel = 0;
4811 device_param->kernel_loops = 0;
4812
4813 return NULL;
4814 }
4815
4816 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4817 {
4818 if (!device_param)
4819 {
4820 log_error ("ERROR: %s : Invalid argument", __func__);
4821
4822 exit (-1);
4823 }
4824
4825 salt_t *salt_buf = &data.salts_buf[salt_pos];
4826
4827 device_param->kernel_params_buf32[24] = salt_pos;
4828 device_param->kernel_params_buf32[27] = 1;
4829 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4830 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4831 device_param->kernel_params_buf32[30] = 0;
4832 device_param->kernel_params_buf32[31] = 1;
4833
4834 char *dictfile_old = data.dictfile;
4835
4836 const char *weak_hash_check = "weak-hash-check";
4837
4838 data.dictfile = (char *) weak_hash_check;
4839
4840 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4841
4842 data.kernel_rules_buf[0].cmds[0] = 0;
4843
4844 /**
4845 * run the kernel
4846 */
4847
4848 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4849 {
4850 run_kernel (KERN_RUN_1, device_param, 1, false);
4851 }
4852 else
4853 {
4854 run_kernel (KERN_RUN_1, device_param, 1, false);
4855
4856 uint loop_step = 16;
4857
4858 const uint iter = salt_buf->salt_iter;
4859
4860 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4861 {
4862 uint loop_left = iter - loop_pos;
4863
4864 loop_left = MIN (loop_left, loop_step);
4865
4866 device_param->kernel_params_buf32[25] = loop_pos;
4867 device_param->kernel_params_buf32[26] = loop_left;
4868
4869 run_kernel (KERN_RUN_2, device_param, 1, false);
4870 }
4871
4872 run_kernel (KERN_RUN_3, device_param, 1, false);
4873 }
4874
4875 /**
4876 * result
4877 */
4878
4879 check_cracked (device_param, salt_pos);
4880
4881 /**
4882 * cleanup
4883 */
4884
4885 device_param->kernel_params_buf32[24] = 0;
4886 device_param->kernel_params_buf32[25] = 0;
4887 device_param->kernel_params_buf32[26] = 0;
4888 device_param->kernel_params_buf32[27] = 0;
4889 device_param->kernel_params_buf32[28] = 0;
4890 device_param->kernel_params_buf32[29] = 0;
4891 device_param->kernel_params_buf32[30] = 0;
4892 device_param->kernel_params_buf32[31] = 0;
4893
4894 data.dictfile = dictfile_old;
4895
4896 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4897 }
4898
4899 // hlfmt hashcat
4900
4901 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4902 {
4903 if (data.username == 0)
4904 {
4905 *hashbuf_pos = line_buf;
4906 *hashbuf_len = line_len;
4907 }
4908 else
4909 {
4910 char *pos = line_buf;
4911 int len = line_len;
4912
4913 for (int i = 0; i < line_len; i++, pos++, len--)
4914 {
4915 if (line_buf[i] == data.separator)
4916 {
4917 pos++;
4918
4919 len--;
4920
4921 break;
4922 }
4923 }
4924
4925 *hashbuf_pos = pos;
4926 *hashbuf_len = len;
4927 }
4928 }
4929
4930 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4931 {
4932 char *pos = NULL;
4933 int len = 0;
4934
4935 int sep_cnt = 0;
4936
4937 for (int i = 0; i < line_len; i++)
4938 {
4939 if (line_buf[i] == data.separator)
4940 {
4941 sep_cnt++;
4942
4943 continue;
4944 }
4945
4946 if (sep_cnt == 0)
4947 {
4948 if (pos == NULL) pos = line_buf + i;
4949
4950 len++;
4951 }
4952 }
4953
4954 *userbuf_pos = pos;
4955 *userbuf_len = len;
4956 }
4957
4958 // hlfmt pwdump
4959
4960 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4961 {
4962 int sep_cnt = 0;
4963
4964 int sep2_len = 0;
4965 int sep3_len = 0;
4966
4967 for (int i = 0; i < line_len; i++)
4968 {
4969 if (line_buf[i] == ':')
4970 {
4971 sep_cnt++;
4972
4973 continue;
4974 }
4975
4976 if (sep_cnt == 2) sep2_len++;
4977 if (sep_cnt == 3) sep3_len++;
4978 }
4979
4980 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4981
4982 return 0;
4983 }
4984
4985 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4986 {
4987 char *pos = NULL;
4988 int len = 0;
4989
4990 int sep_cnt = 0;
4991
4992 for (int i = 0; i < line_len; i++)
4993 {
4994 if (line_buf[i] == ':')
4995 {
4996 sep_cnt++;
4997
4998 continue;
4999 }
5000
5001 if (data.hash_mode == 1000)
5002 {
5003 if (sep_cnt == 3)
5004 {
5005 if (pos == NULL) pos = line_buf + i;
5006
5007 len++;
5008 }
5009 }
5010 else if (data.hash_mode == 3000)
5011 {
5012 if (sep_cnt == 2)
5013 {
5014 if (pos == NULL) pos = line_buf + i;
5015
5016 len++;
5017 }
5018 }
5019 }
5020
5021 *hashbuf_pos = pos;
5022 *hashbuf_len = len;
5023 }
5024
5025 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5026 {
5027 char *pos = NULL;
5028 int len = 0;
5029
5030 int sep_cnt = 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 == 0)
5042 {
5043 if (pos == NULL) pos = line_buf + i;
5044
5045 len++;
5046 }
5047 }
5048
5049 *userbuf_pos = pos;
5050 *userbuf_len = len;
5051 }
5052
5053 // hlfmt passwd
5054
5055 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5056 {
5057 int sep_cnt = 0;
5058
5059 char sep5_first = 0;
5060 char sep6_first = 0;
5061
5062 for (int i = 0; i < line_len; i++)
5063 {
5064 if (line_buf[i] == ':')
5065 {
5066 sep_cnt++;
5067
5068 continue;
5069 }
5070
5071 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5072 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5073 }
5074
5075 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5076
5077 return 0;
5078 }
5079
5080 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5081 {
5082 char *pos = NULL;
5083 int len = 0;
5084
5085 int sep_cnt = 0;
5086
5087 for (int i = 0; i < line_len; i++)
5088 {
5089 if (line_buf[i] == ':')
5090 {
5091 sep_cnt++;
5092
5093 continue;
5094 }
5095
5096 if (sep_cnt == 1)
5097 {
5098 if (pos == NULL) pos = line_buf + i;
5099
5100 len++;
5101 }
5102 }
5103
5104 *hashbuf_pos = pos;
5105 *hashbuf_len = len;
5106 }
5107
5108 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5109 {
5110 char *pos = NULL;
5111 int len = 0;
5112
5113 int sep_cnt = 0;
5114
5115 for (int i = 0; i < line_len; i++)
5116 {
5117 if (line_buf[i] == ':')
5118 {
5119 sep_cnt++;
5120
5121 continue;
5122 }
5123
5124 if (sep_cnt == 0)
5125 {
5126 if (pos == NULL) pos = line_buf + i;
5127
5128 len++;
5129 }
5130 }
5131
5132 *userbuf_pos = pos;
5133 *userbuf_len = len;
5134 }
5135
5136 // hlfmt shadow
5137
5138 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5139 {
5140 int sep_cnt = 0;
5141
5142 for (int i = 0; i < line_len; i++)
5143 {
5144 if (line_buf[i] == ':') sep_cnt++;
5145 }
5146
5147 if (sep_cnt == 8) return 1;
5148
5149 return 0;
5150 }
5151
5152 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5153 {
5154 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5155 }
5156
5157 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5158 {
5159 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5160 }
5161
5162 // hlfmt main
5163
5164 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5165 {
5166 switch (hashfile_format)
5167 {
5168 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5169 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5170 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5171 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5172 }
5173 }
5174
5175 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5176 {
5177 switch (hashfile_format)
5178 {
5179 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5180 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5181 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5182 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5183 }
5184 }
5185
5186 char *strhlfmt (const uint hashfile_format)
5187 {
5188 switch (hashfile_format)
5189 {
5190 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5191 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5192 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5193 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5194 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5195 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5196 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5197 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5198 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5199 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5200 }
5201
5202 return ((char *) "Unknown");
5203 }
5204
5205 static uint hlfmt_detect (FILE *fp, uint max_check)
5206 {
5207 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5208
5209 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5210 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5211
5212 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5213
5214 uint num_check = 0;
5215
5216 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5217
5218 while (!feof (fp))
5219 {
5220 int line_len = fgetl (fp, line_buf);
5221
5222 if (line_len == 0) continue;
5223
5224 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5225 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5226 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5227
5228 if (num_check == max_check) break;
5229
5230 num_check++;
5231 }
5232
5233 myfree (line_buf);
5234
5235 uint hashlist_format = HLFMT_HASHCAT;
5236
5237 for (int i = 1; i < HLFMTS_CNT; i++)
5238 {
5239 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5240
5241 hashlist_format = i;
5242 }
5243
5244 free (formats_cnt);
5245
5246 return hashlist_format;
5247 }
5248
5249 /**
5250 * some further helper function
5251 */
5252
5253 // wrapper around mymalloc for ADL
5254
5255 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5256 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5257 {
5258 return mymalloc (iSize);
5259 }
5260 #endif
5261
5262 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)
5263 {
5264 u64 collisions = 0;
5265
5266 const uint dgst_pos0 = data.dgst_pos0;
5267 const uint dgst_pos1 = data.dgst_pos1;
5268 const uint dgst_pos2 = data.dgst_pos2;
5269 const uint dgst_pos3 = data.dgst_pos3;
5270
5271 memset (bitmap_a, 0, bitmap_size);
5272 memset (bitmap_b, 0, bitmap_size);
5273 memset (bitmap_c, 0, bitmap_size);
5274 memset (bitmap_d, 0, bitmap_size);
5275
5276 for (uint i = 0; i < digests_cnt; i++)
5277 {
5278 uint *digest_ptr = (uint *) digests_buf_ptr;
5279
5280 digests_buf_ptr += dgst_size;
5281
5282 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5283 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5284 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5285 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5286
5287 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5288 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5289 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5290 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5291
5292 if (bitmap_a[idx0] & val0) collisions++;
5293 if (bitmap_b[idx1] & val1) collisions++;
5294 if (bitmap_c[idx2] & val2) collisions++;
5295 if (bitmap_d[idx3] & val3) collisions++;
5296
5297 bitmap_a[idx0] |= val0;
5298 bitmap_b[idx1] |= val1;
5299 bitmap_c[idx2] |= val2;
5300 bitmap_d[idx3] |= val3;
5301
5302 if (collisions >= collisions_max) return 0x7fffffff;
5303 }
5304
5305 return collisions;
5306 }
5307
5308 /**
5309 * main
5310 */
5311
5312 int main (int argc, char **argv)
5313 {
5314 /**
5315 * To help users a bit
5316 */
5317
5318 char *compute = getenv ("COMPUTE");
5319
5320 if (compute)
5321 {
5322 static char display[100];
5323
5324 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5325
5326 putenv (display);
5327 }
5328 else
5329 {
5330 if (getenv ("DISPLAY") == NULL)
5331 putenv ((char *) "DISPLAY=:0");
5332 }
5333
5334 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5335 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5336
5337 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5338 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5339
5340 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5341 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5342
5343 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5344 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5345
5346 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5347 putenv ((char *) "POCL_KERNEL_CACHE=0");
5348
5349 /**
5350 * Real init
5351 */
5352
5353 memset (&data, 0, sizeof (hc_global_data_t));
5354
5355 time_t proc_start;
5356
5357 time (&proc_start);
5358
5359 data.proc_start = proc_start;
5360
5361 int myargc = argc;
5362 char **myargv = argv;
5363
5364 hc_thread_mutex_init (mux_dispatcher);
5365 hc_thread_mutex_init (mux_counter);
5366 hc_thread_mutex_init (mux_display);
5367 hc_thread_mutex_init (mux_adl);
5368
5369 /**
5370 * commandline parameters
5371 */
5372
5373 uint usage = USAGE;
5374 uint version = VERSION;
5375 uint quiet = QUIET;
5376 uint benchmark = BENCHMARK;
5377 uint benchmark_repeats = BENCHMARK_REPEATS;
5378 uint show = SHOW;
5379 uint left = LEFT;
5380 uint username = USERNAME;
5381 uint remove = REMOVE;
5382 uint remove_timer = REMOVE_TIMER;
5383 u64 skip = SKIP;
5384 u64 limit = LIMIT;
5385 uint keyspace = KEYSPACE;
5386 uint potfile_disable = POTFILE_DISABLE;
5387 char *potfile_path = NULL;
5388 uint debug_mode = DEBUG_MODE;
5389 char *debug_file = NULL;
5390 char *induction_dir = NULL;
5391 char *outfile_check_dir = NULL;
5392 uint force = FORCE;
5393 uint runtime = RUNTIME;
5394 uint hash_mode = HASH_MODE;
5395 uint attack_mode = ATTACK_MODE;
5396 uint markov_disable = MARKOV_DISABLE;
5397 uint markov_classic = MARKOV_CLASSIC;
5398 uint markov_threshold = MARKOV_THRESHOLD;
5399 char *markov_hcstat = NULL;
5400 char *outfile = NULL;
5401 uint outfile_format = OUTFILE_FORMAT;
5402 uint outfile_autohex = OUTFILE_AUTOHEX;
5403 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5404 uint restore = RESTORE;
5405 uint restore_timer = RESTORE_TIMER;
5406 uint restore_disable = RESTORE_DISABLE;
5407 uint status = STATUS;
5408 uint status_timer = STATUS_TIMER;
5409 uint status_automat = STATUS_AUTOMAT;
5410 uint loopback = LOOPBACK;
5411 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5412 char *session = NULL;
5413 uint hex_charset = HEX_CHARSET;
5414 uint hex_salt = HEX_SALT;
5415 uint hex_wordlist = HEX_WORDLIST;
5416 uint rp_gen = RP_GEN;
5417 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5418 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5419 uint rp_gen_seed = RP_GEN_SEED;
5420 char *rule_buf_l = (char *) RULE_BUF_L;
5421 char *rule_buf_r = (char *) RULE_BUF_R;
5422 uint increment = INCREMENT;
5423 uint increment_min = INCREMENT_MIN;
5424 uint increment_max = INCREMENT_MAX;
5425 char *cpu_affinity = NULL;
5426 OCL_PTR *ocl = NULL;
5427 char *opencl_devices = NULL;
5428 char *opencl_platforms = NULL;
5429 char *opencl_device_types = NULL;
5430 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5431 char *truecrypt_keyfiles = NULL;
5432 uint workload_profile = WORKLOAD_PROFILE;
5433 uint kernel_accel = KERNEL_ACCEL;
5434 uint kernel_loops = KERNEL_LOOPS;
5435 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5436 #ifdef HAVE_HWMON
5437 uint gpu_temp_abort = GPU_TEMP_ABORT;
5438 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5439 #ifdef HAVE_ADL
5440 uint powertune_enable = POWERTUNE_ENABLE;
5441 #endif
5442 #endif
5443 uint logfile_disable = LOGFILE_DISABLE;
5444 uint segment_size = SEGMENT_SIZE;
5445 uint scrypt_tmto = SCRYPT_TMTO;
5446 char separator = SEPARATOR;
5447 uint bitmap_min = BITMAP_MIN;
5448 uint bitmap_max = BITMAP_MAX;
5449 char *custom_charset_1 = NULL;
5450 char *custom_charset_2 = NULL;
5451 char *custom_charset_3 = NULL;
5452 char *custom_charset_4 = NULL;
5453
5454 #define IDX_HELP 'h'
5455 #define IDX_VERSION 'V'
5456 #define IDX_VERSION_LOWER 'v'
5457 #define IDX_QUIET 0xff02
5458 #define IDX_SHOW 0xff03
5459 #define IDX_LEFT 0xff04
5460 #define IDX_REMOVE 0xff05
5461 #define IDX_REMOVE_TIMER 0xff37
5462 #define IDX_SKIP 's'
5463 #define IDX_LIMIT 'l'
5464 #define IDX_KEYSPACE 0xff35
5465 #define IDX_POTFILE_DISABLE 0xff06
5466 #define IDX_POTFILE_PATH 0xffe0
5467 #define IDX_DEBUG_MODE 0xff43
5468 #define IDX_DEBUG_FILE 0xff44
5469 #define IDX_INDUCTION_DIR 0xff46
5470 #define IDX_OUTFILE_CHECK_DIR 0xff47
5471 #define IDX_USERNAME 0xff07
5472 #define IDX_FORCE 0xff08
5473 #define IDX_RUNTIME 0xff09
5474 #define IDX_BENCHMARK 'b'
5475 #define IDX_BENCHMARK_REPEATS 0xff78
5476 #define IDX_HASH_MODE 'm'
5477 #define IDX_ATTACK_MODE 'a'
5478 #define IDX_RP_FILE 'r'
5479 #define IDX_RP_GEN 'g'
5480 #define IDX_RP_GEN_FUNC_MIN 0xff10
5481 #define IDX_RP_GEN_FUNC_MAX 0xff11
5482 #define IDX_RP_GEN_SEED 0xff34
5483 #define IDX_RULE_BUF_L 'j'
5484 #define IDX_RULE_BUF_R 'k'
5485 #define IDX_INCREMENT 'i'
5486 #define IDX_INCREMENT_MIN 0xff12
5487 #define IDX_INCREMENT_MAX 0xff13
5488 #define IDX_OUTFILE 'o'
5489 #define IDX_OUTFILE_FORMAT 0xff14
5490 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5491 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5492 #define IDX_RESTORE 0xff15
5493 #define IDX_RESTORE_DISABLE 0xff27
5494 #define IDX_STATUS 0xff17
5495 #define IDX_STATUS_TIMER 0xff18
5496 #define IDX_STATUS_AUTOMAT 0xff50
5497 #define IDX_LOOPBACK 0xff38
5498 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5499 #define IDX_SESSION 0xff19
5500 #define IDX_HEX_CHARSET 0xff20
5501 #define IDX_HEX_SALT 0xff21
5502 #define IDX_HEX_WORDLIST 0xff40
5503 #define IDX_MARKOV_DISABLE 0xff22
5504 #define IDX_MARKOV_CLASSIC 0xff23
5505 #define IDX_MARKOV_THRESHOLD 't'
5506 #define IDX_MARKOV_HCSTAT 0xff24
5507 #define IDX_CPU_AFFINITY 0xff25
5508 #define IDX_OPENCL_DEVICES 'd'
5509 #define IDX_OPENCL_PLATFORMS 0xff72
5510 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5511 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5512 #define IDX_WORKLOAD_PROFILE 'w'
5513 #define IDX_KERNEL_ACCEL 'n'
5514 #define IDX_KERNEL_LOOPS 'u'
5515 #define IDX_GPU_TEMP_DISABLE 0xff29
5516 #define IDX_GPU_TEMP_ABORT 0xff30
5517 #define IDX_GPU_TEMP_RETAIN 0xff31
5518 #define IDX_POWERTUNE_ENABLE 0xff41
5519 #define IDX_LOGFILE_DISABLE 0xff51
5520 #define IDX_TRUECRYPT_KEYFILES 0xff52
5521 #define IDX_SCRYPT_TMTO 0xff61
5522 #define IDX_SEGMENT_SIZE 'c'
5523 #define IDX_SEPARATOR 'p'
5524 #define IDX_BITMAP_MIN 0xff70
5525 #define IDX_BITMAP_MAX 0xff71
5526 #define IDX_CUSTOM_CHARSET_1 '1'
5527 #define IDX_CUSTOM_CHARSET_2 '2'
5528 #define IDX_CUSTOM_CHARSET_3 '3'
5529 #define IDX_CUSTOM_CHARSET_4 '4'
5530
5531 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5532
5533 struct option long_options[] =
5534 {
5535 {"help", no_argument, 0, IDX_HELP},
5536 {"version", no_argument, 0, IDX_VERSION},
5537 {"quiet", no_argument, 0, IDX_QUIET},
5538 {"show", no_argument, 0, IDX_SHOW},
5539 {"left", no_argument, 0, IDX_LEFT},
5540 {"username", no_argument, 0, IDX_USERNAME},
5541 {"remove", no_argument, 0, IDX_REMOVE},
5542 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5543 {"skip", required_argument, 0, IDX_SKIP},
5544 {"limit", required_argument, 0, IDX_LIMIT},
5545 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5546 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5547 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5548 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5549 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5550 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5551 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5552 {"force", no_argument, 0, IDX_FORCE},
5553 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5554 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5555 {"restore", no_argument, 0, IDX_RESTORE},
5556 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5557 {"status", no_argument, 0, IDX_STATUS},
5558 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5559 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5560 {"loopback", no_argument, 0, IDX_LOOPBACK},
5561 {"weak-hash-threshold",
5562 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5563 {"session", required_argument, 0, IDX_SESSION},
5564 {"runtime", required_argument, 0, IDX_RUNTIME},
5565 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5566 {"generate-rules-func-min",
5567 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5568 {"generate-rules-func-max",
5569 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5570 {"generate-rules-seed",
5571 required_argument, 0, IDX_RP_GEN_SEED},
5572 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5573 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5574 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5575 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5576 {"rules-file", required_argument, 0, IDX_RP_FILE},
5577 {"outfile", required_argument, 0, IDX_OUTFILE},
5578 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5579 {"outfile-autohex-disable",
5580 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5581 {"outfile-check-timer",
5582 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5583 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5584 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5585 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5586 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5587 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5588 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5589 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5590 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5591 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5592 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5593 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5594 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5595 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5596 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5597 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5598 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5599 #ifdef HAVE_HWMON
5600 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5601 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5602 #ifdef HAVE_ADL
5603 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5604 #endif
5605 #endif // HAVE_HWMON
5606 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5607 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5608 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5609 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5610 // deprecated
5611 {"seperator", required_argument, 0, IDX_SEPARATOR},
5612 {"separator", required_argument, 0, IDX_SEPARATOR},
5613 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5614 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5615 {"increment", no_argument, 0, IDX_INCREMENT},
5616 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5617 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5618 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5619 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5620 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5621 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5622
5623 {0, 0, 0, 0}
5624 };
5625
5626 uint rp_files_cnt = 0;
5627
5628 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5629
5630 int option_index = 0;
5631 int c = -1;
5632
5633 optind = 1;
5634 optopt = 0;
5635
5636 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5637 {
5638 switch (c)
5639 {
5640 case IDX_HELP: usage = 1; break;
5641 case IDX_VERSION:
5642 case IDX_VERSION_LOWER: version = 1; break;
5643 case IDX_RESTORE: restore = 1; break;
5644 case IDX_SESSION: session = optarg; break;
5645 case IDX_SHOW: show = 1; break;
5646 case IDX_LEFT: left = 1; break;
5647 case '?': return (-1);
5648 }
5649 }
5650
5651 if (optopt != 0)
5652 {
5653 log_error ("ERROR: Invalid argument specified");
5654
5655 return (-1);
5656 }
5657
5658 /**
5659 * exit functions
5660 */
5661
5662 if (version)
5663 {
5664 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5665
5666 return (0);
5667 }
5668
5669 if (usage)
5670 {
5671 usage_big_print (PROGNAME);
5672
5673 return (0);
5674 }
5675
5676 /**
5677 * session needs to be set, always!
5678 */
5679
5680 if (session == NULL) session = (char *) PROGNAME;
5681
5682 /**
5683 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5684 */
5685
5686 char *exec_path = get_exec_path ();
5687
5688 #ifdef LINUX
5689
5690 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5691 char *resolved_exec_path = realpath (exec_path, NULL);
5692
5693 char *install_dir = get_install_dir (resolved_exec_path);
5694 char *profile_dir = NULL;
5695 char *session_dir = NULL;
5696 char *shared_dir = NULL;
5697
5698 if (strcmp (install_dir, resolved_install_folder) == 0)
5699 {
5700 struct passwd *pw = getpwuid (getuid ());
5701
5702 const char *homedir = pw->pw_dir;
5703
5704 profile_dir = get_profile_dir (homedir);
5705 session_dir = get_session_dir (profile_dir);
5706 shared_dir = strdup (SHARED_FOLDER);
5707
5708 mkdir (profile_dir, 0700);
5709 mkdir (session_dir, 0700);
5710 }
5711 else
5712 {
5713 profile_dir = install_dir;
5714 session_dir = install_dir;
5715 shared_dir = install_dir;
5716 }
5717
5718 myfree (resolved_install_folder);
5719 myfree (resolved_exec_path);
5720
5721 #else
5722
5723 char *install_dir = get_install_dir (exec_path);
5724 char *profile_dir = install_dir;
5725 char *session_dir = install_dir;
5726 char *shared_dir = install_dir;
5727
5728 #endif
5729
5730 data.install_dir = install_dir;
5731 data.profile_dir = profile_dir;
5732 data.session_dir = session_dir;
5733 data.shared_dir = shared_dir;
5734
5735 myfree (exec_path);
5736
5737 /**
5738 * kernel cache, we need to make sure folder exist
5739 */
5740
5741 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5742
5743 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5744
5745 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5746
5747 mkdir (kernels_folder, 0700);
5748
5749 myfree (kernels_folder);
5750
5751 /**
5752 * session
5753 */
5754
5755 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5756
5757 data.session = session;
5758
5759 char *eff_restore_file = (char *) mymalloc (session_size);
5760 char *new_restore_file = (char *) mymalloc (session_size);
5761
5762 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5763 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5764
5765 data.eff_restore_file = eff_restore_file;
5766 data.new_restore_file = new_restore_file;
5767
5768 if (((show == 1) || (left == 1)) && (restore == 1))
5769 {
5770 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5771 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5772
5773 return (-1);
5774 }
5775
5776 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5777 if ((show == 1) || (left == 1))
5778 {
5779 restore_disable = 1;
5780
5781 restore = 0;
5782 }
5783
5784 data.restore_disable = restore_disable;
5785
5786 restore_data_t *rd = init_restore (argc, argv);
5787
5788 data.rd = rd;
5789
5790 /**
5791 * restore file
5792 */
5793
5794 if (restore == 1)
5795 {
5796 read_restore (eff_restore_file, rd);
5797
5798 if (rd->version_bin < RESTORE_MIN)
5799 {
5800 log_error ("ERROR: Incompatible restore-file version");
5801
5802 return (-1);
5803 }
5804
5805 myargc = rd->argc;
5806 myargv = rd->argv;
5807
5808 #ifdef _POSIX
5809 rd->pid = getpid ();
5810 #elif _WIN
5811 rd->pid = GetCurrentProcessId ();
5812 #endif
5813 }
5814
5815 uint hash_mode_chgd = 0;
5816 uint runtime_chgd = 0;
5817 uint kernel_loops_chgd = 0;
5818 uint kernel_accel_chgd = 0;
5819 uint attack_mode_chgd = 0;
5820 uint outfile_format_chgd = 0;
5821 uint rp_gen_seed_chgd = 0;
5822 uint remove_timer_chgd = 0;
5823 uint increment_min_chgd = 0;
5824 uint increment_max_chgd = 0;
5825 uint workload_profile_chgd = 0;
5826 uint opencl_vector_width_chgd = 0;
5827
5828 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5829 uint gpu_temp_retain_chgd = 0;
5830 uint gpu_temp_abort_chgd = 0;
5831 #endif
5832
5833 optind = 1;
5834 optopt = 0;
5835 option_index = 0;
5836
5837 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5838 {
5839 switch (c)
5840 {
5841 //case IDX_HELP: usage = 1; break;
5842 //case IDX_VERSION: version = 1; break;
5843 //case IDX_RESTORE: restore = 1; break;
5844 case IDX_QUIET: quiet = 1; break;
5845 //case IDX_SHOW: show = 1; break;
5846 case IDX_SHOW: break;
5847 //case IDX_LEFT: left = 1; break;
5848 case IDX_LEFT: break;
5849 case IDX_USERNAME: username = 1; break;
5850 case IDX_REMOVE: remove = 1; break;
5851 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5852 remove_timer_chgd = 1; break;
5853 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5854 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5855 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5856 case IDX_DEBUG_FILE: debug_file = optarg; break;
5857 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5858 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5859 case IDX_FORCE: force = 1; break;
5860 case IDX_SKIP: skip = atoll (optarg); break;
5861 case IDX_LIMIT: limit = atoll (optarg); break;
5862 case IDX_KEYSPACE: keyspace = 1; break;
5863 case IDX_BENCHMARK: benchmark = 1; break;
5864 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5865 case IDX_RESTORE: break;
5866 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5867 case IDX_STATUS: status = 1; break;
5868 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5869 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5870 case IDX_LOOPBACK: loopback = 1; break;
5871 case IDX_WEAK_HASH_THRESHOLD:
5872 weak_hash_threshold = atoi (optarg); break;
5873 //case IDX_SESSION: session = optarg; break;
5874 case IDX_SESSION: break;
5875 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5876 hash_mode_chgd = 1; break;
5877 case IDX_RUNTIME: runtime = atoi (optarg);
5878 runtime_chgd = 1; break;
5879 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5880 attack_mode_chgd = 1; break;
5881 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5882 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5883 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5884 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5885 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5886 rp_gen_seed_chgd = 1; break;
5887 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5888 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5889 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5890 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5891 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5892 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5893 case IDX_OUTFILE: outfile = optarg; break;
5894 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5895 outfile_format_chgd = 1; break;
5896 case IDX_OUTFILE_AUTOHEX_DISABLE:
5897 outfile_autohex = 0; break;
5898 case IDX_OUTFILE_CHECK_TIMER:
5899 outfile_check_timer = atoi (optarg); break;
5900 case IDX_HEX_CHARSET: hex_charset = 1; break;
5901 case IDX_HEX_SALT: hex_salt = 1; break;
5902 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5903 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5904 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5905 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5906 case IDX_OPENCL_DEVICE_TYPES:
5907 opencl_device_types = optarg; break;
5908 case IDX_OPENCL_VECTOR_WIDTH:
5909 opencl_vector_width = atoi (optarg);
5910 opencl_vector_width_chgd = 1; break;
5911 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5912 workload_profile_chgd = 1; break;
5913 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5914 kernel_accel_chgd = 1; break;
5915 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5916 kernel_loops_chgd = 1; break;
5917 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5918 #ifdef HAVE_HWMON
5919 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5920 #ifdef HAVE_ADL
5921 gpu_temp_abort_chgd = 1;
5922 #endif
5923 break;
5924 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5925 #ifdef HAVE_ADL
5926 gpu_temp_retain_chgd = 1;
5927 #endif
5928 break;
5929 #ifdef HAVE_ADL
5930 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5931 #endif
5932 #endif // HAVE_HWMON
5933 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5934 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5935 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5936 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5937 case IDX_SEPARATOR: separator = optarg[0]; break;
5938 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5939 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5940 case IDX_INCREMENT: increment = 1; break;
5941 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5942 increment_min_chgd = 1; break;
5943 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5944 increment_max_chgd = 1; break;
5945 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5946 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5947 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5948 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5949
5950 default:
5951 log_error ("ERROR: Invalid argument specified");
5952 return (-1);
5953 }
5954 }
5955
5956 if (optopt != 0)
5957 {
5958 log_error ("ERROR: Invalid argument specified");
5959
5960 return (-1);
5961 }
5962
5963 /**
5964 * Inform user things getting started,
5965 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5966 * - we do not need to check algorithm_pos
5967 */
5968
5969 if (quiet == 0)
5970 {
5971 if (benchmark == 1)
5972 {
5973 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5974
5975 log_info ("");
5976 }
5977 else if (restore == 1)
5978 {
5979 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5980
5981 log_info ("");
5982 }
5983 else
5984 {
5985 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5986
5987 log_info ("");
5988 }
5989 }
5990
5991 /**
5992 * sanity check
5993 */
5994
5995 if (attack_mode > 7)
5996 {
5997 log_error ("ERROR: Invalid attack-mode specified");
5998
5999 return (-1);
6000 }
6001
6002 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6003 {
6004 log_error ("ERROR: Invalid runtime specified");
6005
6006 return (-1);
6007 }
6008
6009 if (hash_mode_chgd && hash_mode > 13500) // just added to remove compiler warnings for hash_mode_chgd
6010 {
6011 log_error ("ERROR: Invalid hash-type specified");
6012
6013 return (-1);
6014 }
6015
6016 // renamed hash modes
6017
6018 if (hash_mode_chgd)
6019 {
6020 int n = -1;
6021
6022 switch (hash_mode)
6023 {
6024 case 123: n = 124;
6025 break;
6026 }
6027
6028 if (n >= 0)
6029 {
6030 log_error ("Old -m specified, use -m %d instead", n);
6031
6032 return (-1);
6033 }
6034 }
6035
6036 if (username == 1)
6037 {
6038 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6039 {
6040 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6041
6042 return (-1);
6043 }
6044 }
6045
6046 if (outfile_format > 16)
6047 {
6048 log_error ("ERROR: Invalid outfile-format specified");
6049
6050 return (-1);
6051 }
6052
6053 if (left == 1)
6054 {
6055 if (outfile_format_chgd == 1)
6056 {
6057 if (outfile_format > 1)
6058 {
6059 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6060
6061 return (-1);
6062 }
6063 }
6064 else
6065 {
6066 outfile_format = OUTFILE_FMT_HASH;
6067 }
6068 }
6069
6070 if (show == 1)
6071 {
6072 if (outfile_format_chgd == 1)
6073 {
6074 if ((outfile_format > 7) && (outfile_format < 16))
6075 {
6076 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6077
6078 return (-1);
6079 }
6080 }
6081 }
6082
6083 if (increment_min < INCREMENT_MIN)
6084 {
6085 log_error ("ERROR: Invalid increment-min specified");
6086
6087 return (-1);
6088 }
6089
6090 if (increment_max > INCREMENT_MAX)
6091 {
6092 log_error ("ERROR: Invalid increment-max specified");
6093
6094 return (-1);
6095 }
6096
6097 if (increment_min > increment_max)
6098 {
6099 log_error ("ERROR: Invalid increment-min specified");
6100
6101 return (-1);
6102 }
6103
6104 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6105 {
6106 log_error ("ERROR: increment is not allowed in attack-mode 0");
6107
6108 return (-1);
6109 }
6110
6111 if ((increment == 0) && (increment_min_chgd == 1))
6112 {
6113 log_error ("ERROR: increment-min is only supported together with increment switch");
6114
6115 return (-1);
6116 }
6117
6118 if ((increment == 0) && (increment_max_chgd == 1))
6119 {
6120 log_error ("ERROR: increment-max is only supported together with increment switch");
6121
6122 return (-1);
6123 }
6124
6125 if (rp_files_cnt && rp_gen)
6126 {
6127 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6128
6129 return (-1);
6130 }
6131
6132 if (rp_files_cnt || rp_gen)
6133 {
6134 if (attack_mode != ATTACK_MODE_STRAIGHT)
6135 {
6136 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6137
6138 return (-1);
6139 }
6140 }
6141
6142 if (rp_gen_func_min > rp_gen_func_max)
6143 {
6144 log_error ("ERROR: Invalid rp-gen-func-min specified");
6145
6146 return (-1);
6147 }
6148
6149 if (kernel_accel_chgd == 1)
6150 {
6151 if (kernel_accel < 1)
6152 {
6153 log_error ("ERROR: Invalid kernel-accel specified");
6154
6155 return (-1);
6156 }
6157
6158 if (kernel_accel > 1024)
6159 {
6160 log_error ("ERROR: Invalid kernel-accel specified");
6161
6162 return (-1);
6163 }
6164 }
6165
6166 if (kernel_loops_chgd == 1)
6167 {
6168 if (kernel_loops < 1)
6169 {
6170 log_error ("ERROR: Invalid kernel-loops specified");
6171
6172 return (-1);
6173 }
6174
6175 if (kernel_loops > 1024)
6176 {
6177 log_error ("ERROR: Invalid kernel-loops specified");
6178
6179 return (-1);
6180 }
6181 }
6182
6183 if ((workload_profile < 1) || (workload_profile > 3))
6184 {
6185 log_error ("ERROR: workload-profile %i not available", workload_profile);
6186
6187 return (-1);
6188 }
6189
6190 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6191 {
6192 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6193
6194 return (-1);
6195 }
6196
6197 if (show == 1 || left == 1)
6198 {
6199 attack_mode = ATTACK_MODE_NONE;
6200
6201 if (remove == 1)
6202 {
6203 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6204
6205 return (-1);
6206 }
6207
6208 if (potfile_disable == 1)
6209 {
6210 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6211
6212 return (-1);
6213 }
6214 }
6215
6216 uint attack_kern = ATTACK_KERN_NONE;
6217
6218 switch (attack_mode)
6219 {
6220 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6221 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6222 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6223 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6224 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6225 }
6226
6227 if (benchmark == 0)
6228 {
6229 if (keyspace == 1)
6230 {
6231 int num_additional_params = 1;
6232
6233 if (attack_kern == ATTACK_KERN_COMBI)
6234 {
6235 num_additional_params = 2;
6236 }
6237
6238 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6239
6240 if (keyspace_wordlist_specified == 0) optind--;
6241 }
6242
6243 if (attack_kern == ATTACK_KERN_NONE)
6244 {
6245 if ((optind + 1) != myargc)
6246 {
6247 usage_mini_print (myargv[0]);
6248
6249 return (-1);
6250 }
6251 }
6252 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6253 {
6254 if ((optind + 1) > myargc)
6255 {
6256 usage_mini_print (myargv[0]);
6257
6258 return (-1);
6259 }
6260 }
6261 else if (attack_kern == ATTACK_KERN_COMBI)
6262 {
6263 if ((optind + 3) != myargc)
6264 {
6265 usage_mini_print (myargv[0]);
6266
6267 return (-1);
6268 }
6269 }
6270 else if (attack_kern == ATTACK_KERN_BF)
6271 {
6272 if ((optind + 1) > myargc)
6273 {
6274 usage_mini_print (myargv[0]);
6275
6276 return (-1);
6277 }
6278 }
6279 else
6280 {
6281 usage_mini_print (myargv[0]);
6282
6283 return (-1);
6284 }
6285 }
6286 else
6287 {
6288 if (myargv[optind] != 0)
6289 {
6290 log_error ("ERROR: Invalid argument for benchmark mode specified");
6291
6292 return (-1);
6293 }
6294
6295 if (attack_mode_chgd == 1)
6296 {
6297 if (attack_mode != ATTACK_MODE_BF)
6298 {
6299 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6300
6301 return (-1);
6302 }
6303 }
6304 }
6305
6306 if (skip != 0 && limit != 0)
6307 {
6308 limit += skip;
6309 }
6310
6311 if (keyspace == 1)
6312 {
6313 if (show == 1)
6314 {
6315 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6316
6317 return (-1);
6318 }
6319 else if (left == 1)
6320 {
6321 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6322
6323 return (-1);
6324 }
6325
6326 potfile_disable = 1;
6327
6328 restore_disable = 1;
6329
6330 restore = 0;
6331
6332 weak_hash_threshold = 0;
6333
6334 quiet = 1;
6335 }
6336
6337 if (remove_timer_chgd == 1)
6338 {
6339 if (remove == 0)
6340 {
6341 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6342
6343 return (-1);
6344 }
6345
6346 if (remove_timer < 1)
6347 {
6348 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6349
6350 return (-1);
6351 }
6352 }
6353
6354 if (loopback == 1)
6355 {
6356 if (attack_mode == ATTACK_MODE_STRAIGHT)
6357 {
6358 if ((rp_files_cnt == 0) && (rp_gen == 0))
6359 {
6360 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6361
6362 return (-1);
6363 }
6364 }
6365 else
6366 {
6367 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6368
6369 return (-1);
6370 }
6371 }
6372
6373 if (debug_mode > 0)
6374 {
6375 if (attack_mode != ATTACK_MODE_STRAIGHT)
6376 {
6377 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6378
6379 return (-1);
6380 }
6381
6382 if ((rp_files_cnt == 0) && (rp_gen == 0))
6383 {
6384 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6385
6386 return (-1);
6387 }
6388 }
6389
6390 if (debug_mode > 4)
6391 {
6392 log_error ("ERROR: Invalid debug-mode specified");
6393
6394 return (-1);
6395 }
6396
6397 if (debug_file != NULL)
6398 {
6399 if (debug_mode < 1)
6400 {
6401 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6402
6403 return (-1);
6404 }
6405 }
6406
6407 if (induction_dir != NULL)
6408 {
6409 if (attack_mode == ATTACK_MODE_BF)
6410 {
6411 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6412
6413 return (-1);
6414 }
6415 }
6416
6417 if (attack_mode != ATTACK_MODE_STRAIGHT)
6418 {
6419 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6420 {
6421 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6422
6423 return (-1);
6424 }
6425
6426 weak_hash_threshold = 0;
6427 }
6428
6429 /**
6430 * induction directory
6431 */
6432
6433 char *induction_directory = NULL;
6434
6435 if (attack_mode != ATTACK_MODE_BF)
6436 {
6437 if (induction_dir == NULL)
6438 {
6439 induction_directory = (char *) mymalloc (session_size);
6440
6441 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6442
6443 // create induction folder if it does not already exist
6444
6445 if (keyspace == 0)
6446 {
6447 if (rmdir (induction_directory) == -1)
6448 {
6449 if (errno == ENOENT)
6450 {
6451 // good, we can ignore
6452 }
6453 else if (errno == ENOTEMPTY)
6454 {
6455 char *induction_directory_mv = (char *) mymalloc (session_size);
6456
6457 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6458
6459 if (rename (induction_directory, induction_directory_mv) != 0)
6460 {
6461 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6462
6463 return (-1);
6464 }
6465 }
6466 else
6467 {
6468 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6469
6470 return (-1);
6471 }
6472 }
6473
6474 if (mkdir (induction_directory, 0700) == -1)
6475 {
6476 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6477
6478 return (-1);
6479 }
6480 }
6481 }
6482 else
6483 {
6484 induction_directory = induction_dir;
6485 }
6486 }
6487
6488 data.induction_directory = induction_directory;
6489
6490 /**
6491 * loopback
6492 */
6493
6494 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6495
6496 char *loopback_file = (char *) mymalloc (loopback_size);
6497
6498 /**
6499 * tuning db
6500 */
6501
6502 char tuning_db_file[256] = { 0 };
6503
6504 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6505
6506 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6507
6508 /**
6509 * outfile-check directory
6510 */
6511
6512 char *outfile_check_directory = NULL;
6513
6514 if (outfile_check_dir == NULL)
6515 {
6516 outfile_check_directory = (char *) mymalloc (session_size);
6517
6518 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6519 }
6520 else
6521 {
6522 outfile_check_directory = outfile_check_dir;
6523 }
6524
6525 data.outfile_check_directory = outfile_check_directory;
6526
6527 if (keyspace == 0)
6528 {
6529 struct stat outfile_check_stat;
6530
6531 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6532 {
6533 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6534
6535 if (is_dir == 0)
6536 {
6537 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6538
6539 return (-1);
6540 }
6541 }
6542 else if (outfile_check_dir == NULL)
6543 {
6544 if (mkdir (outfile_check_directory, 0700) == -1)
6545 {
6546 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6547
6548 return (-1);
6549 }
6550 }
6551 }
6552
6553 /**
6554 * special other stuff
6555 */
6556
6557 if (hash_mode == 9710)
6558 {
6559 outfile_format = 5;
6560 outfile_format_chgd = 1;
6561 }
6562
6563 if (hash_mode == 9810)
6564 {
6565 outfile_format = 5;
6566 outfile_format_chgd = 1;
6567 }
6568
6569 if (hash_mode == 10410)
6570 {
6571 outfile_format = 5;
6572 outfile_format_chgd = 1;
6573 }
6574
6575 /**
6576 * store stuff
6577 */
6578
6579 data.hash_mode = hash_mode;
6580 data.restore = restore;
6581 data.restore_timer = restore_timer;
6582 data.restore_disable = restore_disable;
6583 data.status = status;
6584 data.status_timer = status_timer;
6585 data.status_automat = status_automat;
6586 data.loopback = loopback;
6587 data.runtime = runtime;
6588 data.remove = remove;
6589 data.remove_timer = remove_timer;
6590 data.debug_mode = debug_mode;
6591 data.debug_file = debug_file;
6592 data.username = username;
6593 data.quiet = quiet;
6594 data.outfile = outfile;
6595 data.outfile_format = outfile_format;
6596 data.outfile_autohex = outfile_autohex;
6597 data.hex_charset = hex_charset;
6598 data.hex_salt = hex_salt;
6599 data.hex_wordlist = hex_wordlist;
6600 data.separator = separator;
6601 data.rp_files = rp_files;
6602 data.rp_files_cnt = rp_files_cnt;
6603 data.rp_gen = rp_gen;
6604 data.rp_gen_seed = rp_gen_seed;
6605 data.force = force;
6606 data.benchmark = benchmark;
6607 data.benchmark_repeats = benchmark_repeats;
6608 data.skip = skip;
6609 data.limit = limit;
6610 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6611 data.powertune_enable = powertune_enable;
6612 #endif
6613 data.logfile_disable = logfile_disable;
6614 data.truecrypt_keyfiles = truecrypt_keyfiles;
6615 data.scrypt_tmto = scrypt_tmto;
6616 data.workload_profile = workload_profile;
6617
6618 /**
6619 * cpu affinity
6620 */
6621
6622 if (cpu_affinity)
6623 {
6624 set_cpu_affinity (cpu_affinity);
6625 }
6626
6627 if (rp_gen_seed_chgd == 0)
6628 {
6629 srand (proc_start);
6630 }
6631 else
6632 {
6633 srand (rp_gen_seed);
6634 }
6635
6636 /**
6637 * logfile init
6638 */
6639
6640 if (logfile_disable == 0)
6641 {
6642 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6643
6644 char *logfile = (char *) mymalloc (logfile_size);
6645
6646 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6647
6648 data.logfile = logfile;
6649
6650 char *topid = logfile_generate_topid ();
6651
6652 data.topid = topid;
6653 }
6654
6655 // logfile_append() checks for logfile_disable internally to make it easier from here
6656
6657 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6658 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6659 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6660 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6661 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6662 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6663 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6664 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6665 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6666 #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));
6667
6668 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6669 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6670 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6671 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6672 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6673 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6674 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6675 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6676
6677 logfile_top_msg ("START");
6678
6679 logfile_top_uint (attack_mode);
6680 logfile_top_uint (attack_kern);
6681 logfile_top_uint (benchmark);
6682 logfile_top_uint (benchmark_repeats);
6683 logfile_top_uint (bitmap_min);
6684 logfile_top_uint (bitmap_max);
6685 logfile_top_uint (debug_mode);
6686 logfile_top_uint (force);
6687 logfile_top_uint (kernel_accel);
6688 logfile_top_uint (kernel_loops);
6689 logfile_top_uint (gpu_temp_disable);
6690 #ifdef HAVE_HWMON
6691 logfile_top_uint (gpu_temp_abort);
6692 logfile_top_uint (gpu_temp_retain);
6693 #endif
6694 logfile_top_uint (hash_mode);
6695 logfile_top_uint (hex_charset);
6696 logfile_top_uint (hex_salt);
6697 logfile_top_uint (hex_wordlist);
6698 logfile_top_uint (increment);
6699 logfile_top_uint (increment_max);
6700 logfile_top_uint (increment_min);
6701 logfile_top_uint (keyspace);
6702 logfile_top_uint (left);
6703 logfile_top_uint (logfile_disable);
6704 logfile_top_uint (loopback);
6705 logfile_top_uint (markov_classic);
6706 logfile_top_uint (markov_disable);
6707 logfile_top_uint (markov_threshold);
6708 logfile_top_uint (outfile_autohex);
6709 logfile_top_uint (outfile_check_timer);
6710 logfile_top_uint (outfile_format);
6711 logfile_top_uint (potfile_disable);
6712 logfile_top_string (potfile_path);
6713 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6714 logfile_top_uint (powertune_enable);
6715 #endif
6716 logfile_top_uint (scrypt_tmto);
6717 logfile_top_uint (quiet);
6718 logfile_top_uint (remove);
6719 logfile_top_uint (remove_timer);
6720 logfile_top_uint (restore);
6721 logfile_top_uint (restore_disable);
6722 logfile_top_uint (restore_timer);
6723 logfile_top_uint (rp_gen);
6724 logfile_top_uint (rp_gen_func_max);
6725 logfile_top_uint (rp_gen_func_min);
6726 logfile_top_uint (rp_gen_seed);
6727 logfile_top_uint (runtime);
6728 logfile_top_uint (segment_size);
6729 logfile_top_uint (show);
6730 logfile_top_uint (status);
6731 logfile_top_uint (status_automat);
6732 logfile_top_uint (status_timer);
6733 logfile_top_uint (usage);
6734 logfile_top_uint (username);
6735 logfile_top_uint (version);
6736 logfile_top_uint (weak_hash_threshold);
6737 logfile_top_uint (workload_profile);
6738 logfile_top_uint64 (limit);
6739 logfile_top_uint64 (skip);
6740 logfile_top_char (separator);
6741 logfile_top_string (cpu_affinity);
6742 logfile_top_string (custom_charset_1);
6743 logfile_top_string (custom_charset_2);
6744 logfile_top_string (custom_charset_3);
6745 logfile_top_string (custom_charset_4);
6746 logfile_top_string (debug_file);
6747 logfile_top_string (opencl_devices);
6748 logfile_top_string (opencl_platforms);
6749 logfile_top_string (opencl_device_types);
6750 logfile_top_uint (opencl_vector_width);
6751 logfile_top_string (induction_dir);
6752 logfile_top_string (markov_hcstat);
6753 logfile_top_string (outfile);
6754 logfile_top_string (outfile_check_dir);
6755 logfile_top_string (rule_buf_l);
6756 logfile_top_string (rule_buf_r);
6757 logfile_top_string (session);
6758 logfile_top_string (truecrypt_keyfiles);
6759
6760 /**
6761 * Init OpenCL library loader
6762 */
6763
6764 if (keyspace == 0)
6765 {
6766 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6767
6768 ocl_init (ocl);
6769
6770 data.ocl = ocl;
6771 }
6772
6773 /**
6774 * OpenCL platform selection
6775 */
6776
6777 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6778
6779 /**
6780 * OpenCL device selection
6781 */
6782
6783 u32 devices_filter = setup_devices_filter (opencl_devices);
6784
6785 /**
6786 * OpenCL device type selection
6787 */
6788
6789 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6790
6791 /**
6792 * benchmark
6793 */
6794
6795 if (benchmark == 1)
6796 {
6797 /**
6798 * disable useless stuff for benchmark
6799 */
6800
6801 status_timer = 0;
6802 restore_timer = 0;
6803 restore_disable = 1;
6804 potfile_disable = 1;
6805 weak_hash_threshold = 0;
6806 gpu_temp_disable = 1;
6807
6808 data.status_timer = status_timer;
6809 data.restore_timer = restore_timer;
6810 data.restore_disable = restore_disable;
6811
6812 /**
6813 * force attack mode to be bruteforce
6814 */
6815
6816 attack_mode = ATTACK_MODE_BF;
6817 attack_kern = ATTACK_KERN_BF;
6818
6819 if (workload_profile_chgd == 0)
6820 {
6821 workload_profile = 3;
6822
6823 data.workload_profile = workload_profile;
6824 }
6825 }
6826
6827 /**
6828 * config
6829 */
6830
6831 uint hash_type = 0;
6832 uint salt_type = 0;
6833 uint attack_exec = 0;
6834 uint opts_type = 0;
6835 uint kern_type = 0;
6836 uint dgst_size = 0;
6837 uint esalt_size = 0;
6838 uint opti_type = 0;
6839 uint dgst_pos0 = -1;
6840 uint dgst_pos1 = -1;
6841 uint dgst_pos2 = -1;
6842 uint dgst_pos3 = -1;
6843
6844 int (*parse_func) (char *, uint, hash_t *);
6845 int (*sort_by_digest) (const void *, const void *);
6846
6847 uint algorithm_pos = 0;
6848 uint algorithm_max = 1;
6849
6850 uint *algorithms = default_benchmark_algorithms;
6851
6852 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6853
6854 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6855 {
6856 /*
6857 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6858 * the following algos are skipped entirely
6859 */
6860
6861 if (algorithm_pos > 0)
6862 {
6863 local_free (rd);
6864
6865 rd = init_restore (argc, argv);
6866
6867 data.rd = rd;
6868 }
6869
6870 /**
6871 * update hash_mode in case of multihash benchmark
6872 */
6873
6874 if (benchmark == 1)
6875 {
6876 if (hash_mode_chgd == 0)
6877 {
6878 hash_mode = algorithms[algorithm_pos];
6879
6880 data.hash_mode = hash_mode;
6881 }
6882
6883 quiet = 1;
6884
6885 data.quiet = quiet;
6886 }
6887
6888 switch (hash_mode)
6889 {
6890 case 0: hash_type = HASH_TYPE_MD5;
6891 salt_type = SALT_TYPE_NONE;
6892 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6893 opts_type = OPTS_TYPE_PT_GENERATE_LE
6894 | OPTS_TYPE_PT_ADD80
6895 | OPTS_TYPE_PT_ADDBITS14;
6896 kern_type = KERN_TYPE_MD5;
6897 dgst_size = DGST_SIZE_4_4;
6898 parse_func = md5_parse_hash;
6899 sort_by_digest = sort_by_digest_4_4;
6900 opti_type = OPTI_TYPE_ZERO_BYTE
6901 | OPTI_TYPE_PRECOMPUTE_INIT
6902 | OPTI_TYPE_PRECOMPUTE_MERKLE
6903 | OPTI_TYPE_MEET_IN_MIDDLE
6904 | OPTI_TYPE_EARLY_SKIP
6905 | OPTI_TYPE_NOT_ITERATED
6906 | OPTI_TYPE_NOT_SALTED
6907 | OPTI_TYPE_RAW_HASH;
6908 dgst_pos0 = 0;
6909 dgst_pos1 = 3;
6910 dgst_pos2 = 2;
6911 dgst_pos3 = 1;
6912 break;
6913
6914 case 10: hash_type = HASH_TYPE_MD5;
6915 salt_type = SALT_TYPE_INTERN;
6916 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6917 opts_type = OPTS_TYPE_PT_GENERATE_LE
6918 | OPTS_TYPE_ST_ADD80
6919 | OPTS_TYPE_ST_ADDBITS14;
6920 kern_type = KERN_TYPE_MD5_PWSLT;
6921 dgst_size = DGST_SIZE_4_4;
6922 parse_func = md5s_parse_hash;
6923 sort_by_digest = sort_by_digest_4_4;
6924 opti_type = OPTI_TYPE_ZERO_BYTE
6925 | OPTI_TYPE_PRECOMPUTE_INIT
6926 | OPTI_TYPE_PRECOMPUTE_MERKLE
6927 | OPTI_TYPE_MEET_IN_MIDDLE
6928 | OPTI_TYPE_EARLY_SKIP
6929 | OPTI_TYPE_NOT_ITERATED
6930 | OPTI_TYPE_APPENDED_SALT
6931 | OPTI_TYPE_RAW_HASH;
6932 dgst_pos0 = 0;
6933 dgst_pos1 = 3;
6934 dgst_pos2 = 2;
6935 dgst_pos3 = 1;
6936 break;
6937
6938 case 11: hash_type = HASH_TYPE_MD5;
6939 salt_type = SALT_TYPE_INTERN;
6940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6941 opts_type = OPTS_TYPE_PT_GENERATE_LE
6942 | OPTS_TYPE_ST_ADD80
6943 | OPTS_TYPE_ST_ADDBITS14;
6944 kern_type = KERN_TYPE_MD5_PWSLT;
6945 dgst_size = DGST_SIZE_4_4;
6946 parse_func = joomla_parse_hash;
6947 sort_by_digest = sort_by_digest_4_4;
6948 opti_type = OPTI_TYPE_ZERO_BYTE
6949 | OPTI_TYPE_PRECOMPUTE_INIT
6950 | OPTI_TYPE_PRECOMPUTE_MERKLE
6951 | OPTI_TYPE_MEET_IN_MIDDLE
6952 | OPTI_TYPE_EARLY_SKIP
6953 | OPTI_TYPE_NOT_ITERATED
6954 | OPTI_TYPE_APPENDED_SALT
6955 | OPTI_TYPE_RAW_HASH;
6956 dgst_pos0 = 0;
6957 dgst_pos1 = 3;
6958 dgst_pos2 = 2;
6959 dgst_pos3 = 1;
6960 break;
6961
6962 case 12: hash_type = HASH_TYPE_MD5;
6963 salt_type = SALT_TYPE_INTERN;
6964 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6965 opts_type = OPTS_TYPE_PT_GENERATE_LE
6966 | OPTS_TYPE_ST_ADD80
6967 | OPTS_TYPE_ST_ADDBITS14;
6968 kern_type = KERN_TYPE_MD5_PWSLT;
6969 dgst_size = DGST_SIZE_4_4;
6970 parse_func = postgresql_parse_hash;
6971 sort_by_digest = sort_by_digest_4_4;
6972 opti_type = OPTI_TYPE_ZERO_BYTE
6973 | OPTI_TYPE_PRECOMPUTE_INIT
6974 | OPTI_TYPE_PRECOMPUTE_MERKLE
6975 | OPTI_TYPE_MEET_IN_MIDDLE
6976 | OPTI_TYPE_EARLY_SKIP
6977 | OPTI_TYPE_NOT_ITERATED
6978 | OPTI_TYPE_APPENDED_SALT
6979 | OPTI_TYPE_RAW_HASH;
6980 dgst_pos0 = 0;
6981 dgst_pos1 = 3;
6982 dgst_pos2 = 2;
6983 dgst_pos3 = 1;
6984 break;
6985
6986 case 20: hash_type = HASH_TYPE_MD5;
6987 salt_type = SALT_TYPE_INTERN;
6988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6989 opts_type = OPTS_TYPE_PT_GENERATE_LE
6990 | OPTS_TYPE_PT_ADD80
6991 | OPTS_TYPE_PT_ADDBITS14;
6992 kern_type = KERN_TYPE_MD5_SLTPW;
6993 dgst_size = DGST_SIZE_4_4;
6994 parse_func = md5s_parse_hash;
6995 sort_by_digest = sort_by_digest_4_4;
6996 opti_type = OPTI_TYPE_ZERO_BYTE
6997 | OPTI_TYPE_PRECOMPUTE_INIT
6998 | OPTI_TYPE_PRECOMPUTE_MERKLE
6999 | OPTI_TYPE_EARLY_SKIP
7000 | OPTI_TYPE_NOT_ITERATED
7001 | OPTI_TYPE_PREPENDED_SALT
7002 | OPTI_TYPE_RAW_HASH;
7003 dgst_pos0 = 0;
7004 dgst_pos1 = 3;
7005 dgst_pos2 = 2;
7006 dgst_pos3 = 1;
7007 break;
7008
7009 case 21: hash_type = HASH_TYPE_MD5;
7010 salt_type = SALT_TYPE_INTERN;
7011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7012 opts_type = OPTS_TYPE_PT_GENERATE_LE
7013 | OPTS_TYPE_PT_ADD80
7014 | OPTS_TYPE_PT_ADDBITS14;
7015 kern_type = KERN_TYPE_MD5_SLTPW;
7016 dgst_size = DGST_SIZE_4_4;
7017 parse_func = osc_parse_hash;
7018 sort_by_digest = sort_by_digest_4_4;
7019 opti_type = OPTI_TYPE_ZERO_BYTE
7020 | OPTI_TYPE_PRECOMPUTE_INIT
7021 | OPTI_TYPE_PRECOMPUTE_MERKLE
7022 | OPTI_TYPE_EARLY_SKIP
7023 | OPTI_TYPE_NOT_ITERATED
7024 | OPTI_TYPE_PREPENDED_SALT
7025 | OPTI_TYPE_RAW_HASH;
7026 dgst_pos0 = 0;
7027 dgst_pos1 = 3;
7028 dgst_pos2 = 2;
7029 dgst_pos3 = 1;
7030 break;
7031
7032 case 22: hash_type = HASH_TYPE_MD5;
7033 salt_type = SALT_TYPE_EMBEDDED;
7034 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7035 opts_type = OPTS_TYPE_PT_GENERATE_LE
7036 | OPTS_TYPE_PT_ADD80
7037 | OPTS_TYPE_PT_ADDBITS14;
7038 kern_type = KERN_TYPE_MD5_SLTPW;
7039 dgst_size = DGST_SIZE_4_4;
7040 parse_func = netscreen_parse_hash;
7041 sort_by_digest = sort_by_digest_4_4;
7042 opti_type = OPTI_TYPE_ZERO_BYTE
7043 | OPTI_TYPE_PRECOMPUTE_INIT
7044 | OPTI_TYPE_PRECOMPUTE_MERKLE
7045 | OPTI_TYPE_EARLY_SKIP
7046 | OPTI_TYPE_NOT_ITERATED
7047 | OPTI_TYPE_PREPENDED_SALT
7048 | OPTI_TYPE_RAW_HASH;
7049 dgst_pos0 = 0;
7050 dgst_pos1 = 3;
7051 dgst_pos2 = 2;
7052 dgst_pos3 = 1;
7053 break;
7054
7055 case 23: hash_type = HASH_TYPE_MD5;
7056 salt_type = SALT_TYPE_EMBEDDED;
7057 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7058 opts_type = OPTS_TYPE_PT_GENERATE_LE
7059 | OPTS_TYPE_PT_ADD80
7060 | OPTS_TYPE_PT_ADDBITS14;
7061 kern_type = KERN_TYPE_MD5_SLTPW;
7062 dgst_size = DGST_SIZE_4_4;
7063 parse_func = skype_parse_hash;
7064 sort_by_digest = sort_by_digest_4_4;
7065 opti_type = OPTI_TYPE_ZERO_BYTE
7066 | OPTI_TYPE_PRECOMPUTE_INIT
7067 | OPTI_TYPE_PRECOMPUTE_MERKLE
7068 | OPTI_TYPE_EARLY_SKIP
7069 | OPTI_TYPE_NOT_ITERATED
7070 | OPTI_TYPE_PREPENDED_SALT
7071 | OPTI_TYPE_RAW_HASH;
7072 dgst_pos0 = 0;
7073 dgst_pos1 = 3;
7074 dgst_pos2 = 2;
7075 dgst_pos3 = 1;
7076 break;
7077
7078 case 30: hash_type = HASH_TYPE_MD5;
7079 salt_type = SALT_TYPE_INTERN;
7080 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7081 opts_type = OPTS_TYPE_PT_GENERATE_LE
7082 | OPTS_TYPE_PT_UNICODE
7083 | OPTS_TYPE_ST_ADD80
7084 | OPTS_TYPE_ST_ADDBITS14;
7085 kern_type = KERN_TYPE_MD5_PWUSLT;
7086 dgst_size = DGST_SIZE_4_4;
7087 parse_func = md5s_parse_hash;
7088 sort_by_digest = sort_by_digest_4_4;
7089 opti_type = OPTI_TYPE_ZERO_BYTE
7090 | OPTI_TYPE_PRECOMPUTE_INIT
7091 | OPTI_TYPE_PRECOMPUTE_MERKLE
7092 | OPTI_TYPE_MEET_IN_MIDDLE
7093 | OPTI_TYPE_EARLY_SKIP
7094 | OPTI_TYPE_NOT_ITERATED
7095 | OPTI_TYPE_APPENDED_SALT
7096 | OPTI_TYPE_RAW_HASH;
7097 dgst_pos0 = 0;
7098 dgst_pos1 = 3;
7099 dgst_pos2 = 2;
7100 dgst_pos3 = 1;
7101 break;
7102
7103 case 40: hash_type = HASH_TYPE_MD5;
7104 salt_type = SALT_TYPE_INTERN;
7105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7106 opts_type = OPTS_TYPE_PT_GENERATE_LE
7107 | OPTS_TYPE_PT_ADD80
7108 | OPTS_TYPE_PT_ADDBITS14
7109 | OPTS_TYPE_PT_UNICODE;
7110 kern_type = KERN_TYPE_MD5_SLTPWU;
7111 dgst_size = DGST_SIZE_4_4;
7112 parse_func = md5s_parse_hash;
7113 sort_by_digest = sort_by_digest_4_4;
7114 opti_type = OPTI_TYPE_ZERO_BYTE
7115 | OPTI_TYPE_PRECOMPUTE_INIT
7116 | OPTI_TYPE_PRECOMPUTE_MERKLE
7117 | OPTI_TYPE_EARLY_SKIP
7118 | OPTI_TYPE_NOT_ITERATED
7119 | OPTI_TYPE_PREPENDED_SALT
7120 | OPTI_TYPE_RAW_HASH;
7121 dgst_pos0 = 0;
7122 dgst_pos1 = 3;
7123 dgst_pos2 = 2;
7124 dgst_pos3 = 1;
7125 break;
7126
7127 case 50: hash_type = HASH_TYPE_MD5;
7128 salt_type = SALT_TYPE_INTERN;
7129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7130 opts_type = OPTS_TYPE_PT_GENERATE_LE
7131 | OPTS_TYPE_ST_ADD80
7132 | OPTS_TYPE_ST_ADDBITS14;
7133 kern_type = KERN_TYPE_HMACMD5_PW;
7134 dgst_size = DGST_SIZE_4_4;
7135 parse_func = hmacmd5_parse_hash;
7136 sort_by_digest = sort_by_digest_4_4;
7137 opti_type = OPTI_TYPE_ZERO_BYTE
7138 | OPTI_TYPE_NOT_ITERATED;
7139 dgst_pos0 = 0;
7140 dgst_pos1 = 3;
7141 dgst_pos2 = 2;
7142 dgst_pos3 = 1;
7143 break;
7144
7145 case 60: hash_type = HASH_TYPE_MD5;
7146 salt_type = SALT_TYPE_INTERN;
7147 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7148 opts_type = OPTS_TYPE_PT_GENERATE_LE
7149 | OPTS_TYPE_PT_ADD80
7150 | OPTS_TYPE_PT_ADDBITS14;
7151 kern_type = KERN_TYPE_HMACMD5_SLT;
7152 dgst_size = DGST_SIZE_4_4;
7153 parse_func = hmacmd5_parse_hash;
7154 sort_by_digest = sort_by_digest_4_4;
7155 opti_type = OPTI_TYPE_ZERO_BYTE
7156 | OPTI_TYPE_NOT_ITERATED;
7157 dgst_pos0 = 0;
7158 dgst_pos1 = 3;
7159 dgst_pos2 = 2;
7160 dgst_pos3 = 1;
7161 break;
7162
7163 case 100: hash_type = HASH_TYPE_SHA1;
7164 salt_type = SALT_TYPE_NONE;
7165 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7166 opts_type = OPTS_TYPE_PT_GENERATE_BE
7167 | OPTS_TYPE_PT_ADD80
7168 | OPTS_TYPE_PT_ADDBITS15;
7169 kern_type = KERN_TYPE_SHA1;
7170 dgst_size = DGST_SIZE_4_5;
7171 parse_func = sha1_parse_hash;
7172 sort_by_digest = sort_by_digest_4_5;
7173 opti_type = OPTI_TYPE_ZERO_BYTE
7174 | OPTI_TYPE_PRECOMPUTE_INIT
7175 | OPTI_TYPE_PRECOMPUTE_MERKLE
7176 | OPTI_TYPE_EARLY_SKIP
7177 | OPTI_TYPE_NOT_ITERATED
7178 | OPTI_TYPE_NOT_SALTED
7179 | OPTI_TYPE_RAW_HASH;
7180 dgst_pos0 = 3;
7181 dgst_pos1 = 4;
7182 dgst_pos2 = 2;
7183 dgst_pos3 = 1;
7184 break;
7185
7186 case 101: hash_type = HASH_TYPE_SHA1;
7187 salt_type = SALT_TYPE_NONE;
7188 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7189 opts_type = OPTS_TYPE_PT_GENERATE_BE
7190 | OPTS_TYPE_PT_ADD80
7191 | OPTS_TYPE_PT_ADDBITS15;
7192 kern_type = KERN_TYPE_SHA1;
7193 dgst_size = DGST_SIZE_4_5;
7194 parse_func = sha1b64_parse_hash;
7195 sort_by_digest = sort_by_digest_4_5;
7196 opti_type = OPTI_TYPE_ZERO_BYTE
7197 | OPTI_TYPE_PRECOMPUTE_INIT
7198 | OPTI_TYPE_PRECOMPUTE_MERKLE
7199 | OPTI_TYPE_EARLY_SKIP
7200 | OPTI_TYPE_NOT_ITERATED
7201 | OPTI_TYPE_NOT_SALTED
7202 | OPTI_TYPE_RAW_HASH;
7203 dgst_pos0 = 3;
7204 dgst_pos1 = 4;
7205 dgst_pos2 = 2;
7206 dgst_pos3 = 1;
7207 break;
7208
7209 case 110: hash_type = HASH_TYPE_SHA1;
7210 salt_type = SALT_TYPE_INTERN;
7211 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7212 opts_type = OPTS_TYPE_PT_GENERATE_BE
7213 | OPTS_TYPE_ST_ADD80
7214 | OPTS_TYPE_ST_ADDBITS15;
7215 kern_type = KERN_TYPE_SHA1_PWSLT;
7216 dgst_size = DGST_SIZE_4_5;
7217 parse_func = sha1s_parse_hash;
7218 sort_by_digest = sort_by_digest_4_5;
7219 opti_type = OPTI_TYPE_ZERO_BYTE
7220 | OPTI_TYPE_PRECOMPUTE_INIT
7221 | OPTI_TYPE_PRECOMPUTE_MERKLE
7222 | OPTI_TYPE_EARLY_SKIP
7223 | OPTI_TYPE_NOT_ITERATED
7224 | OPTI_TYPE_APPENDED_SALT
7225 | OPTI_TYPE_RAW_HASH;
7226 dgst_pos0 = 3;
7227 dgst_pos1 = 4;
7228 dgst_pos2 = 2;
7229 dgst_pos3 = 1;
7230 break;
7231
7232 case 111: hash_type = HASH_TYPE_SHA1;
7233 salt_type = SALT_TYPE_EMBEDDED;
7234 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7235 opts_type = OPTS_TYPE_PT_GENERATE_BE
7236 | OPTS_TYPE_ST_ADD80
7237 | OPTS_TYPE_ST_ADDBITS15;
7238 kern_type = KERN_TYPE_SHA1_PWSLT;
7239 dgst_size = DGST_SIZE_4_5;
7240 parse_func = sha1b64s_parse_hash;
7241 sort_by_digest = sort_by_digest_4_5;
7242 opti_type = OPTI_TYPE_ZERO_BYTE
7243 | OPTI_TYPE_PRECOMPUTE_INIT
7244 | OPTI_TYPE_PRECOMPUTE_MERKLE
7245 | OPTI_TYPE_EARLY_SKIP
7246 | OPTI_TYPE_NOT_ITERATED
7247 | OPTI_TYPE_APPENDED_SALT
7248 | OPTI_TYPE_RAW_HASH;
7249 dgst_pos0 = 3;
7250 dgst_pos1 = 4;
7251 dgst_pos2 = 2;
7252 dgst_pos3 = 1;
7253 break;
7254
7255 case 112: hash_type = HASH_TYPE_SHA1;
7256 salt_type = SALT_TYPE_INTERN;
7257 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7258 opts_type = OPTS_TYPE_PT_GENERATE_BE
7259 | OPTS_TYPE_ST_ADD80
7260 | OPTS_TYPE_ST_ADDBITS15
7261 | OPTS_TYPE_ST_HEX;
7262 kern_type = KERN_TYPE_SHA1_PWSLT;
7263 dgst_size = DGST_SIZE_4_5;
7264 parse_func = oracles_parse_hash;
7265 sort_by_digest = sort_by_digest_4_5;
7266 opti_type = OPTI_TYPE_ZERO_BYTE
7267 | OPTI_TYPE_PRECOMPUTE_INIT
7268 | OPTI_TYPE_PRECOMPUTE_MERKLE
7269 | OPTI_TYPE_EARLY_SKIP
7270 | OPTI_TYPE_NOT_ITERATED
7271 | OPTI_TYPE_APPENDED_SALT
7272 | OPTI_TYPE_RAW_HASH;
7273 dgst_pos0 = 3;
7274 dgst_pos1 = 4;
7275 dgst_pos2 = 2;
7276 dgst_pos3 = 1;
7277 break;
7278
7279 case 120: hash_type = HASH_TYPE_SHA1;
7280 salt_type = SALT_TYPE_INTERN;
7281 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7282 opts_type = OPTS_TYPE_PT_GENERATE_BE
7283 | OPTS_TYPE_PT_ADD80
7284 | OPTS_TYPE_PT_ADDBITS15;
7285 kern_type = KERN_TYPE_SHA1_SLTPW;
7286 dgst_size = DGST_SIZE_4_5;
7287 parse_func = sha1s_parse_hash;
7288 sort_by_digest = sort_by_digest_4_5;
7289 opti_type = OPTI_TYPE_ZERO_BYTE
7290 | OPTI_TYPE_PRECOMPUTE_INIT
7291 | OPTI_TYPE_PRECOMPUTE_MERKLE
7292 | OPTI_TYPE_EARLY_SKIP
7293 | OPTI_TYPE_NOT_ITERATED
7294 | OPTI_TYPE_PREPENDED_SALT
7295 | OPTI_TYPE_RAW_HASH;
7296 dgst_pos0 = 3;
7297 dgst_pos1 = 4;
7298 dgst_pos2 = 2;
7299 dgst_pos3 = 1;
7300 break;
7301
7302 case 121: hash_type = HASH_TYPE_SHA1;
7303 salt_type = SALT_TYPE_INTERN;
7304 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7305 opts_type = OPTS_TYPE_PT_GENERATE_BE
7306 | OPTS_TYPE_PT_ADD80
7307 | OPTS_TYPE_PT_ADDBITS15
7308 | OPTS_TYPE_ST_LOWER;
7309 kern_type = KERN_TYPE_SHA1_SLTPW;
7310 dgst_size = DGST_SIZE_4_5;
7311 parse_func = smf_parse_hash;
7312 sort_by_digest = sort_by_digest_4_5;
7313 opti_type = OPTI_TYPE_ZERO_BYTE
7314 | OPTI_TYPE_PRECOMPUTE_INIT
7315 | OPTI_TYPE_PRECOMPUTE_MERKLE
7316 | OPTI_TYPE_EARLY_SKIP
7317 | OPTI_TYPE_NOT_ITERATED
7318 | OPTI_TYPE_PREPENDED_SALT
7319 | OPTI_TYPE_RAW_HASH;
7320 dgst_pos0 = 3;
7321 dgst_pos1 = 4;
7322 dgst_pos2 = 2;
7323 dgst_pos3 = 1;
7324 break;
7325
7326 case 122: hash_type = HASH_TYPE_SHA1;
7327 salt_type = SALT_TYPE_EMBEDDED;
7328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7329 opts_type = OPTS_TYPE_PT_GENERATE_BE
7330 | OPTS_TYPE_PT_ADD80
7331 | OPTS_TYPE_PT_ADDBITS15
7332 | OPTS_TYPE_ST_HEX;
7333 kern_type = KERN_TYPE_SHA1_SLTPW;
7334 dgst_size = DGST_SIZE_4_5;
7335 parse_func = osx1_parse_hash;
7336 sort_by_digest = sort_by_digest_4_5;
7337 opti_type = OPTI_TYPE_ZERO_BYTE
7338 | OPTI_TYPE_PRECOMPUTE_INIT
7339 | OPTI_TYPE_PRECOMPUTE_MERKLE
7340 | OPTI_TYPE_EARLY_SKIP
7341 | OPTI_TYPE_NOT_ITERATED
7342 | OPTI_TYPE_PREPENDED_SALT
7343 | OPTI_TYPE_RAW_HASH;
7344 dgst_pos0 = 3;
7345 dgst_pos1 = 4;
7346 dgst_pos2 = 2;
7347 dgst_pos3 = 1;
7348 break;
7349
7350 case 124: hash_type = HASH_TYPE_SHA1;
7351 salt_type = SALT_TYPE_EMBEDDED;
7352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7353 opts_type = OPTS_TYPE_PT_GENERATE_BE
7354 | OPTS_TYPE_PT_ADD80
7355 | OPTS_TYPE_PT_ADDBITS15;
7356 kern_type = KERN_TYPE_SHA1_SLTPW;
7357 dgst_size = DGST_SIZE_4_5;
7358 parse_func = djangosha1_parse_hash;
7359 sort_by_digest = sort_by_digest_4_5;
7360 opti_type = OPTI_TYPE_ZERO_BYTE
7361 | OPTI_TYPE_PRECOMPUTE_INIT
7362 | OPTI_TYPE_PRECOMPUTE_MERKLE
7363 | OPTI_TYPE_EARLY_SKIP
7364 | OPTI_TYPE_NOT_ITERATED
7365 | OPTI_TYPE_PREPENDED_SALT
7366 | OPTI_TYPE_RAW_HASH;
7367 dgst_pos0 = 3;
7368 dgst_pos1 = 4;
7369 dgst_pos2 = 2;
7370 dgst_pos3 = 1;
7371 break;
7372
7373 case 125: hash_type = HASH_TYPE_SHA1;
7374 salt_type = SALT_TYPE_EMBEDDED;
7375 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7376 opts_type = OPTS_TYPE_PT_GENERATE_BE
7377 | OPTS_TYPE_PT_ADD80
7378 | OPTS_TYPE_PT_ADDBITS15
7379 | OPTS_TYPE_ST_HEX;
7380 kern_type = KERN_TYPE_SHA1_SLTPW;
7381 dgst_size = DGST_SIZE_4_5;
7382 parse_func = arubaos_parse_hash;
7383 sort_by_digest = sort_by_digest_4_5;
7384 opti_type = OPTI_TYPE_ZERO_BYTE
7385 | OPTI_TYPE_PRECOMPUTE_INIT
7386 | OPTI_TYPE_PRECOMPUTE_MERKLE
7387 | OPTI_TYPE_EARLY_SKIP
7388 | OPTI_TYPE_NOT_ITERATED
7389 | OPTI_TYPE_PREPENDED_SALT
7390 | OPTI_TYPE_RAW_HASH;
7391 dgst_pos0 = 3;
7392 dgst_pos1 = 4;
7393 dgst_pos2 = 2;
7394 dgst_pos3 = 1;
7395 break;
7396
7397 case 130: hash_type = HASH_TYPE_SHA1;
7398 salt_type = SALT_TYPE_INTERN;
7399 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7400 opts_type = OPTS_TYPE_PT_GENERATE_BE
7401 | OPTS_TYPE_PT_UNICODE
7402 | OPTS_TYPE_ST_ADD80
7403 | OPTS_TYPE_ST_ADDBITS15;
7404 kern_type = KERN_TYPE_SHA1_PWUSLT;
7405 dgst_size = DGST_SIZE_4_5;
7406 parse_func = sha1s_parse_hash;
7407 sort_by_digest = sort_by_digest_4_5;
7408 opti_type = OPTI_TYPE_ZERO_BYTE
7409 | OPTI_TYPE_PRECOMPUTE_INIT
7410 | OPTI_TYPE_PRECOMPUTE_MERKLE
7411 | OPTI_TYPE_EARLY_SKIP
7412 | OPTI_TYPE_NOT_ITERATED
7413 | OPTI_TYPE_APPENDED_SALT
7414 | OPTI_TYPE_RAW_HASH;
7415 dgst_pos0 = 3;
7416 dgst_pos1 = 4;
7417 dgst_pos2 = 2;
7418 dgst_pos3 = 1;
7419 break;
7420
7421 case 131: hash_type = HASH_TYPE_SHA1;
7422 salt_type = SALT_TYPE_EMBEDDED;
7423 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7424 opts_type = OPTS_TYPE_PT_GENERATE_BE
7425 | OPTS_TYPE_PT_UNICODE
7426 | OPTS_TYPE_PT_UPPER
7427 | OPTS_TYPE_ST_ADD80
7428 | OPTS_TYPE_ST_ADDBITS15
7429 | OPTS_TYPE_ST_HEX;
7430 kern_type = KERN_TYPE_SHA1_PWUSLT;
7431 dgst_size = DGST_SIZE_4_5;
7432 parse_func = mssql2000_parse_hash;
7433 sort_by_digest = sort_by_digest_4_5;
7434 opti_type = OPTI_TYPE_ZERO_BYTE
7435 | OPTI_TYPE_PRECOMPUTE_INIT
7436 | OPTI_TYPE_PRECOMPUTE_MERKLE
7437 | OPTI_TYPE_EARLY_SKIP
7438 | OPTI_TYPE_NOT_ITERATED
7439 | OPTI_TYPE_APPENDED_SALT
7440 | OPTI_TYPE_RAW_HASH;
7441 dgst_pos0 = 3;
7442 dgst_pos1 = 4;
7443 dgst_pos2 = 2;
7444 dgst_pos3 = 1;
7445 break;
7446
7447 case 132: hash_type = HASH_TYPE_SHA1;
7448 salt_type = SALT_TYPE_EMBEDDED;
7449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7450 opts_type = OPTS_TYPE_PT_GENERATE_BE
7451 | OPTS_TYPE_PT_UNICODE
7452 | OPTS_TYPE_ST_ADD80
7453 | OPTS_TYPE_ST_ADDBITS15
7454 | OPTS_TYPE_ST_HEX;
7455 kern_type = KERN_TYPE_SHA1_PWUSLT;
7456 dgst_size = DGST_SIZE_4_5;
7457 parse_func = mssql2005_parse_hash;
7458 sort_by_digest = sort_by_digest_4_5;
7459 opti_type = OPTI_TYPE_ZERO_BYTE
7460 | OPTI_TYPE_PRECOMPUTE_INIT
7461 | OPTI_TYPE_PRECOMPUTE_MERKLE
7462 | OPTI_TYPE_EARLY_SKIP
7463 | OPTI_TYPE_NOT_ITERATED
7464 | OPTI_TYPE_APPENDED_SALT
7465 | OPTI_TYPE_RAW_HASH;
7466 dgst_pos0 = 3;
7467 dgst_pos1 = 4;
7468 dgst_pos2 = 2;
7469 dgst_pos3 = 1;
7470 break;
7471
7472 case 133: hash_type = HASH_TYPE_SHA1;
7473 salt_type = SALT_TYPE_EMBEDDED;
7474 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7475 opts_type = OPTS_TYPE_PT_GENERATE_BE
7476 | OPTS_TYPE_PT_UNICODE
7477 | OPTS_TYPE_ST_ADD80
7478 | OPTS_TYPE_ST_ADDBITS15;
7479 kern_type = KERN_TYPE_SHA1_PWUSLT;
7480 dgst_size = DGST_SIZE_4_5;
7481 parse_func = peoplesoft_parse_hash;
7482 sort_by_digest = sort_by_digest_4_5;
7483 opti_type = OPTI_TYPE_ZERO_BYTE
7484 | OPTI_TYPE_PRECOMPUTE_INIT
7485 | OPTI_TYPE_PRECOMPUTE_MERKLE
7486 | OPTI_TYPE_EARLY_SKIP
7487 | OPTI_TYPE_NOT_ITERATED
7488 | OPTI_TYPE_APPENDED_SALT
7489 | OPTI_TYPE_RAW_HASH;
7490 dgst_pos0 = 3;
7491 dgst_pos1 = 4;
7492 dgst_pos2 = 2;
7493 dgst_pos3 = 1;
7494 break;
7495
7496 case 140: hash_type = HASH_TYPE_SHA1;
7497 salt_type = SALT_TYPE_INTERN;
7498 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7499 opts_type = OPTS_TYPE_PT_GENERATE_BE
7500 | OPTS_TYPE_PT_ADD80
7501 | OPTS_TYPE_PT_ADDBITS15
7502 | OPTS_TYPE_PT_UNICODE;
7503 kern_type = KERN_TYPE_SHA1_SLTPWU;
7504 dgst_size = DGST_SIZE_4_5;
7505 parse_func = sha1s_parse_hash;
7506 sort_by_digest = sort_by_digest_4_5;
7507 opti_type = OPTI_TYPE_ZERO_BYTE
7508 | OPTI_TYPE_PRECOMPUTE_INIT
7509 | OPTI_TYPE_PRECOMPUTE_MERKLE
7510 | OPTI_TYPE_EARLY_SKIP
7511 | OPTI_TYPE_NOT_ITERATED
7512 | OPTI_TYPE_PREPENDED_SALT
7513 | OPTI_TYPE_RAW_HASH;
7514 dgst_pos0 = 3;
7515 dgst_pos1 = 4;
7516 dgst_pos2 = 2;
7517 dgst_pos3 = 1;
7518 break;
7519
7520 case 141: hash_type = HASH_TYPE_SHA1;
7521 salt_type = SALT_TYPE_EMBEDDED;
7522 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7523 opts_type = OPTS_TYPE_PT_GENERATE_BE
7524 | OPTS_TYPE_PT_ADD80
7525 | OPTS_TYPE_PT_ADDBITS15
7526 | OPTS_TYPE_PT_UNICODE
7527 | OPTS_TYPE_ST_BASE64;
7528 kern_type = KERN_TYPE_SHA1_SLTPWU;
7529 dgst_size = DGST_SIZE_4_5;
7530 parse_func = episerver_parse_hash;
7531 sort_by_digest = sort_by_digest_4_5;
7532 opti_type = OPTI_TYPE_ZERO_BYTE
7533 | OPTI_TYPE_PRECOMPUTE_INIT
7534 | OPTI_TYPE_PRECOMPUTE_MERKLE
7535 | OPTI_TYPE_EARLY_SKIP
7536 | OPTI_TYPE_NOT_ITERATED
7537 | OPTI_TYPE_PREPENDED_SALT
7538 | OPTI_TYPE_RAW_HASH;
7539 dgst_pos0 = 3;
7540 dgst_pos1 = 4;
7541 dgst_pos2 = 2;
7542 dgst_pos3 = 1;
7543 break;
7544
7545 case 150: hash_type = HASH_TYPE_SHA1;
7546 salt_type = SALT_TYPE_INTERN;
7547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7548 opts_type = OPTS_TYPE_PT_GENERATE_BE
7549 | OPTS_TYPE_ST_ADD80
7550 | OPTS_TYPE_ST_ADDBITS15;
7551 kern_type = KERN_TYPE_HMACSHA1_PW;
7552 dgst_size = DGST_SIZE_4_5;
7553 parse_func = hmacsha1_parse_hash;
7554 sort_by_digest = sort_by_digest_4_5;
7555 opti_type = OPTI_TYPE_ZERO_BYTE
7556 | OPTI_TYPE_NOT_ITERATED;
7557 dgst_pos0 = 3;
7558 dgst_pos1 = 4;
7559 dgst_pos2 = 2;
7560 dgst_pos3 = 1;
7561 break;
7562
7563 case 160: hash_type = HASH_TYPE_SHA1;
7564 salt_type = SALT_TYPE_INTERN;
7565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7566 opts_type = OPTS_TYPE_PT_GENERATE_BE
7567 | OPTS_TYPE_PT_ADD80
7568 | OPTS_TYPE_PT_ADDBITS15;
7569 kern_type = KERN_TYPE_HMACSHA1_SLT;
7570 dgst_size = DGST_SIZE_4_5;
7571 parse_func = hmacsha1_parse_hash;
7572 sort_by_digest = sort_by_digest_4_5;
7573 opti_type = OPTI_TYPE_ZERO_BYTE
7574 | OPTI_TYPE_NOT_ITERATED;
7575 dgst_pos0 = 3;
7576 dgst_pos1 = 4;
7577 dgst_pos2 = 2;
7578 dgst_pos3 = 1;
7579 break;
7580
7581 case 190: hash_type = HASH_TYPE_SHA1;
7582 salt_type = SALT_TYPE_NONE;
7583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7584 opts_type = OPTS_TYPE_PT_GENERATE_BE
7585 | OPTS_TYPE_PT_ADD80
7586 | OPTS_TYPE_PT_ADDBITS15;
7587 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7588 dgst_size = DGST_SIZE_4_5;
7589 parse_func = sha1linkedin_parse_hash;
7590 sort_by_digest = sort_by_digest_4_5;
7591 opti_type = OPTI_TYPE_ZERO_BYTE
7592 | OPTI_TYPE_PRECOMPUTE_INIT
7593 | OPTI_TYPE_EARLY_SKIP
7594 | OPTI_TYPE_NOT_ITERATED
7595 | OPTI_TYPE_NOT_SALTED;
7596 dgst_pos0 = 0;
7597 dgst_pos1 = 4;
7598 dgst_pos2 = 3;
7599 dgst_pos3 = 2;
7600 break;
7601
7602 case 200: hash_type = HASH_TYPE_MYSQL;
7603 salt_type = SALT_TYPE_NONE;
7604 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7605 opts_type = 0;
7606 kern_type = KERN_TYPE_MYSQL;
7607 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7608 parse_func = mysql323_parse_hash;
7609 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7610 opti_type = OPTI_TYPE_ZERO_BYTE;
7611 dgst_pos0 = 0;
7612 dgst_pos1 = 1;
7613 dgst_pos2 = 2;
7614 dgst_pos3 = 3;
7615 break;
7616
7617 case 300: hash_type = HASH_TYPE_SHA1;
7618 salt_type = SALT_TYPE_NONE;
7619 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7620 opts_type = OPTS_TYPE_PT_GENERATE_BE
7621 | OPTS_TYPE_PT_ADD80
7622 | OPTS_TYPE_PT_ADDBITS15;
7623 kern_type = KERN_TYPE_MYSQL41;
7624 dgst_size = DGST_SIZE_4_5;
7625 parse_func = sha1_parse_hash;
7626 sort_by_digest = sort_by_digest_4_5;
7627 opti_type = OPTI_TYPE_ZERO_BYTE
7628 | OPTI_TYPE_PRECOMPUTE_INIT
7629 | OPTI_TYPE_PRECOMPUTE_MERKLE
7630 | OPTI_TYPE_EARLY_SKIP
7631 | OPTI_TYPE_NOT_ITERATED
7632 | OPTI_TYPE_NOT_SALTED;
7633 dgst_pos0 = 3;
7634 dgst_pos1 = 4;
7635 dgst_pos2 = 2;
7636 dgst_pos3 = 1;
7637 break;
7638
7639 case 400: hash_type = HASH_TYPE_MD5;
7640 salt_type = SALT_TYPE_EMBEDDED;
7641 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7642 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7643 kern_type = KERN_TYPE_PHPASS;
7644 dgst_size = DGST_SIZE_4_4;
7645 parse_func = phpass_parse_hash;
7646 sort_by_digest = sort_by_digest_4_4;
7647 opti_type = OPTI_TYPE_ZERO_BYTE
7648 | OPTI_TYPE_SLOW_HASH_SIMD;
7649 dgst_pos0 = 0;
7650 dgst_pos1 = 1;
7651 dgst_pos2 = 2;
7652 dgst_pos3 = 3;
7653 break;
7654
7655 case 500: hash_type = HASH_TYPE_MD5;
7656 salt_type = SALT_TYPE_EMBEDDED;
7657 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7658 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7659 kern_type = KERN_TYPE_MD5CRYPT;
7660 dgst_size = DGST_SIZE_4_4;
7661 parse_func = md5crypt_parse_hash;
7662 sort_by_digest = sort_by_digest_4_4;
7663 opti_type = OPTI_TYPE_ZERO_BYTE;
7664 dgst_pos0 = 0;
7665 dgst_pos1 = 1;
7666 dgst_pos2 = 2;
7667 dgst_pos3 = 3;
7668 break;
7669
7670 case 501: hash_type = HASH_TYPE_MD5;
7671 salt_type = SALT_TYPE_EMBEDDED;
7672 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7673 opts_type = OPTS_TYPE_PT_GENERATE_LE
7674 | OPTS_TYPE_HASH_COPY;
7675 kern_type = KERN_TYPE_MD5CRYPT;
7676 dgst_size = DGST_SIZE_4_4;
7677 parse_func = juniper_parse_hash;
7678 sort_by_digest = sort_by_digest_4_4;
7679 opti_type = OPTI_TYPE_ZERO_BYTE;
7680 dgst_pos0 = 0;
7681 dgst_pos1 = 1;
7682 dgst_pos2 = 2;
7683 dgst_pos3 = 3;
7684 break;
7685
7686 case 900: hash_type = HASH_TYPE_MD4;
7687 salt_type = SALT_TYPE_NONE;
7688 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7689 opts_type = OPTS_TYPE_PT_GENERATE_LE
7690 | OPTS_TYPE_PT_ADD80
7691 | OPTS_TYPE_PT_ADDBITS14;
7692 kern_type = KERN_TYPE_MD4;
7693 dgst_size = DGST_SIZE_4_4;
7694 parse_func = md4_parse_hash;
7695 sort_by_digest = sort_by_digest_4_4;
7696 opti_type = OPTI_TYPE_ZERO_BYTE
7697 | OPTI_TYPE_PRECOMPUTE_INIT
7698 | OPTI_TYPE_PRECOMPUTE_MERKLE
7699 | OPTI_TYPE_MEET_IN_MIDDLE
7700 | OPTI_TYPE_EARLY_SKIP
7701 | OPTI_TYPE_NOT_ITERATED
7702 | OPTI_TYPE_NOT_SALTED
7703 | OPTI_TYPE_RAW_HASH;
7704 dgst_pos0 = 0;
7705 dgst_pos1 = 3;
7706 dgst_pos2 = 2;
7707 dgst_pos3 = 1;
7708 break;
7709
7710 case 1000: hash_type = HASH_TYPE_MD4;
7711 salt_type = SALT_TYPE_NONE;
7712 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7713 opts_type = OPTS_TYPE_PT_GENERATE_LE
7714 | OPTS_TYPE_PT_ADD80
7715 | OPTS_TYPE_PT_ADDBITS14
7716 | OPTS_TYPE_PT_UNICODE;
7717 kern_type = KERN_TYPE_MD4_PWU;
7718 dgst_size = DGST_SIZE_4_4;
7719 parse_func = md4_parse_hash;
7720 sort_by_digest = sort_by_digest_4_4;
7721 opti_type = OPTI_TYPE_ZERO_BYTE
7722 | OPTI_TYPE_PRECOMPUTE_INIT
7723 | OPTI_TYPE_PRECOMPUTE_MERKLE
7724 | OPTI_TYPE_MEET_IN_MIDDLE
7725 | OPTI_TYPE_EARLY_SKIP
7726 | OPTI_TYPE_NOT_ITERATED
7727 | OPTI_TYPE_NOT_SALTED
7728 | OPTI_TYPE_RAW_HASH;
7729 dgst_pos0 = 0;
7730 dgst_pos1 = 3;
7731 dgst_pos2 = 2;
7732 dgst_pos3 = 1;
7733 break;
7734
7735 case 1100: hash_type = HASH_TYPE_MD4;
7736 salt_type = SALT_TYPE_INTERN;
7737 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7738 opts_type = OPTS_TYPE_PT_GENERATE_LE
7739 | OPTS_TYPE_PT_ADD80
7740 | OPTS_TYPE_PT_ADDBITS14
7741 | OPTS_TYPE_PT_UNICODE
7742 | OPTS_TYPE_ST_ADD80
7743 | OPTS_TYPE_ST_UNICODE
7744 | OPTS_TYPE_ST_LOWER;
7745 kern_type = KERN_TYPE_MD44_PWUSLT;
7746 dgst_size = DGST_SIZE_4_4;
7747 parse_func = dcc_parse_hash;
7748 sort_by_digest = sort_by_digest_4_4;
7749 opti_type = OPTI_TYPE_ZERO_BYTE
7750 | OPTI_TYPE_PRECOMPUTE_INIT
7751 | OPTI_TYPE_PRECOMPUTE_MERKLE
7752 | OPTI_TYPE_EARLY_SKIP
7753 | OPTI_TYPE_NOT_ITERATED;
7754 dgst_pos0 = 0;
7755 dgst_pos1 = 3;
7756 dgst_pos2 = 2;
7757 dgst_pos3 = 1;
7758 break;
7759
7760 case 1400: hash_type = HASH_TYPE_SHA256;
7761 salt_type = SALT_TYPE_NONE;
7762 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7763 opts_type = OPTS_TYPE_PT_GENERATE_BE
7764 | OPTS_TYPE_PT_ADD80
7765 | OPTS_TYPE_PT_ADDBITS15;
7766 kern_type = KERN_TYPE_SHA256;
7767 dgst_size = DGST_SIZE_4_8;
7768 parse_func = sha256_parse_hash;
7769 sort_by_digest = sort_by_digest_4_8;
7770 opti_type = OPTI_TYPE_ZERO_BYTE
7771 | OPTI_TYPE_PRECOMPUTE_INIT
7772 | OPTI_TYPE_PRECOMPUTE_MERKLE
7773 | OPTI_TYPE_EARLY_SKIP
7774 | OPTI_TYPE_NOT_ITERATED
7775 | OPTI_TYPE_NOT_SALTED
7776 | OPTI_TYPE_RAW_HASH;
7777 dgst_pos0 = 3;
7778 dgst_pos1 = 7;
7779 dgst_pos2 = 2;
7780 dgst_pos3 = 6;
7781 break;
7782
7783 case 1410: hash_type = HASH_TYPE_SHA256;
7784 salt_type = SALT_TYPE_INTERN;
7785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7786 opts_type = OPTS_TYPE_PT_GENERATE_BE
7787 | OPTS_TYPE_ST_ADD80
7788 | OPTS_TYPE_ST_ADDBITS15;
7789 kern_type = KERN_TYPE_SHA256_PWSLT;
7790 dgst_size = DGST_SIZE_4_8;
7791 parse_func = sha256s_parse_hash;
7792 sort_by_digest = sort_by_digest_4_8;
7793 opti_type = OPTI_TYPE_ZERO_BYTE
7794 | OPTI_TYPE_PRECOMPUTE_INIT
7795 | OPTI_TYPE_PRECOMPUTE_MERKLE
7796 | OPTI_TYPE_EARLY_SKIP
7797 | OPTI_TYPE_NOT_ITERATED
7798 | OPTI_TYPE_APPENDED_SALT
7799 | OPTI_TYPE_RAW_HASH;
7800 dgst_pos0 = 3;
7801 dgst_pos1 = 7;
7802 dgst_pos2 = 2;
7803 dgst_pos3 = 6;
7804 break;
7805
7806 case 1420: hash_type = HASH_TYPE_SHA256;
7807 salt_type = SALT_TYPE_INTERN;
7808 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7809 opts_type = OPTS_TYPE_PT_GENERATE_BE
7810 | OPTS_TYPE_PT_ADD80
7811 | OPTS_TYPE_PT_ADDBITS15;
7812 kern_type = KERN_TYPE_SHA256_SLTPW;
7813 dgst_size = DGST_SIZE_4_8;
7814 parse_func = sha256s_parse_hash;
7815 sort_by_digest = sort_by_digest_4_8;
7816 opti_type = OPTI_TYPE_ZERO_BYTE
7817 | OPTI_TYPE_PRECOMPUTE_INIT
7818 | OPTI_TYPE_PRECOMPUTE_MERKLE
7819 | OPTI_TYPE_EARLY_SKIP
7820 | OPTI_TYPE_NOT_ITERATED
7821 | OPTI_TYPE_PREPENDED_SALT
7822 | OPTI_TYPE_RAW_HASH;
7823 dgst_pos0 = 3;
7824 dgst_pos1 = 7;
7825 dgst_pos2 = 2;
7826 dgst_pos3 = 6;
7827 break;
7828
7829 case 1421: hash_type = HASH_TYPE_SHA256;
7830 salt_type = SALT_TYPE_EMBEDDED;
7831 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7832 opts_type = OPTS_TYPE_PT_GENERATE_BE
7833 | OPTS_TYPE_PT_ADD80
7834 | OPTS_TYPE_PT_ADDBITS15;
7835 kern_type = KERN_TYPE_SHA256_SLTPW;
7836 dgst_size = DGST_SIZE_4_8;
7837 parse_func = hmailserver_parse_hash;
7838 sort_by_digest = sort_by_digest_4_8;
7839 opti_type = OPTI_TYPE_ZERO_BYTE
7840 | OPTI_TYPE_PRECOMPUTE_INIT
7841 | OPTI_TYPE_PRECOMPUTE_MERKLE
7842 | OPTI_TYPE_EARLY_SKIP
7843 | OPTI_TYPE_NOT_ITERATED
7844 | OPTI_TYPE_PREPENDED_SALT
7845 | OPTI_TYPE_RAW_HASH;
7846 dgst_pos0 = 3;
7847 dgst_pos1 = 7;
7848 dgst_pos2 = 2;
7849 dgst_pos3 = 6;
7850 break;
7851
7852 case 1430: hash_type = HASH_TYPE_SHA256;
7853 salt_type = SALT_TYPE_INTERN;
7854 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7855 opts_type = OPTS_TYPE_PT_GENERATE_BE
7856 | OPTS_TYPE_PT_UNICODE
7857 | OPTS_TYPE_ST_ADD80
7858 | OPTS_TYPE_ST_ADDBITS15;
7859 kern_type = KERN_TYPE_SHA256_PWUSLT;
7860 dgst_size = DGST_SIZE_4_8;
7861 parse_func = sha256s_parse_hash;
7862 sort_by_digest = sort_by_digest_4_8;
7863 opti_type = OPTI_TYPE_ZERO_BYTE
7864 | OPTI_TYPE_PRECOMPUTE_INIT
7865 | OPTI_TYPE_PRECOMPUTE_MERKLE
7866 | OPTI_TYPE_EARLY_SKIP
7867 | OPTI_TYPE_NOT_ITERATED
7868 | OPTI_TYPE_APPENDED_SALT
7869 | OPTI_TYPE_RAW_HASH;
7870 dgst_pos0 = 3;
7871 dgst_pos1 = 7;
7872 dgst_pos2 = 2;
7873 dgst_pos3 = 6;
7874 break;
7875
7876 case 1440: hash_type = HASH_TYPE_SHA256;
7877 salt_type = SALT_TYPE_INTERN;
7878 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7879 opts_type = OPTS_TYPE_PT_GENERATE_BE
7880 | OPTS_TYPE_PT_ADD80
7881 | OPTS_TYPE_PT_ADDBITS15
7882 | OPTS_TYPE_PT_UNICODE;
7883 kern_type = KERN_TYPE_SHA256_SLTPWU;
7884 dgst_size = DGST_SIZE_4_8;
7885 parse_func = sha256s_parse_hash;
7886 sort_by_digest = sort_by_digest_4_8;
7887 opti_type = OPTI_TYPE_ZERO_BYTE
7888 | OPTI_TYPE_PRECOMPUTE_INIT
7889 | OPTI_TYPE_PRECOMPUTE_MERKLE
7890 | OPTI_TYPE_EARLY_SKIP
7891 | OPTI_TYPE_NOT_ITERATED
7892 | OPTI_TYPE_PREPENDED_SALT
7893 | OPTI_TYPE_RAW_HASH;
7894 dgst_pos0 = 3;
7895 dgst_pos1 = 7;
7896 dgst_pos2 = 2;
7897 dgst_pos3 = 6;
7898 break;
7899
7900 case 1441: hash_type = HASH_TYPE_SHA256;
7901 salt_type = SALT_TYPE_EMBEDDED;
7902 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7903 opts_type = OPTS_TYPE_PT_GENERATE_BE
7904 | OPTS_TYPE_PT_ADD80
7905 | OPTS_TYPE_PT_ADDBITS15
7906 | OPTS_TYPE_PT_UNICODE
7907 | OPTS_TYPE_ST_BASE64;
7908 kern_type = KERN_TYPE_SHA256_SLTPWU;
7909 dgst_size = DGST_SIZE_4_8;
7910 parse_func = episerver4_parse_hash;
7911 sort_by_digest = sort_by_digest_4_8;
7912 opti_type = OPTI_TYPE_ZERO_BYTE
7913 | OPTI_TYPE_PRECOMPUTE_INIT
7914 | OPTI_TYPE_PRECOMPUTE_MERKLE
7915 | OPTI_TYPE_EARLY_SKIP
7916 | OPTI_TYPE_NOT_ITERATED
7917 | OPTI_TYPE_PREPENDED_SALT
7918 | OPTI_TYPE_RAW_HASH;
7919 dgst_pos0 = 3;
7920 dgst_pos1 = 7;
7921 dgst_pos2 = 2;
7922 dgst_pos3 = 6;
7923 break;
7924
7925 case 1450: hash_type = HASH_TYPE_SHA256;
7926 salt_type = SALT_TYPE_INTERN;
7927 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7928 opts_type = OPTS_TYPE_PT_GENERATE_BE
7929 | OPTS_TYPE_ST_ADD80;
7930 kern_type = KERN_TYPE_HMACSHA256_PW;
7931 dgst_size = DGST_SIZE_4_8;
7932 parse_func = hmacsha256_parse_hash;
7933 sort_by_digest = sort_by_digest_4_8;
7934 opti_type = OPTI_TYPE_ZERO_BYTE
7935 | OPTI_TYPE_NOT_ITERATED;
7936 dgst_pos0 = 3;
7937 dgst_pos1 = 7;
7938 dgst_pos2 = 2;
7939 dgst_pos3 = 6;
7940 break;
7941
7942 case 1460: hash_type = HASH_TYPE_SHA256;
7943 salt_type = SALT_TYPE_INTERN;
7944 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7945 opts_type = OPTS_TYPE_PT_GENERATE_BE
7946 | OPTS_TYPE_PT_ADD80
7947 | OPTS_TYPE_PT_ADDBITS15;
7948 kern_type = KERN_TYPE_HMACSHA256_SLT;
7949 dgst_size = DGST_SIZE_4_8;
7950 parse_func = hmacsha256_parse_hash;
7951 sort_by_digest = sort_by_digest_4_8;
7952 opti_type = OPTI_TYPE_ZERO_BYTE
7953 | OPTI_TYPE_NOT_ITERATED;
7954 dgst_pos0 = 3;
7955 dgst_pos1 = 7;
7956 dgst_pos2 = 2;
7957 dgst_pos3 = 6;
7958 break;
7959
7960 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7961 salt_type = SALT_TYPE_EMBEDDED;
7962 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7963 opts_type = OPTS_TYPE_PT_GENERATE_LE
7964 | OPTS_TYPE_PT_BITSLICE;
7965 kern_type = KERN_TYPE_DESCRYPT;
7966 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7967 parse_func = descrypt_parse_hash;
7968 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7969 opti_type = OPTI_TYPE_ZERO_BYTE
7970 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7971 dgst_pos0 = 0;
7972 dgst_pos1 = 1;
7973 dgst_pos2 = 2;
7974 dgst_pos3 = 3;
7975 break;
7976
7977 case 1600: hash_type = HASH_TYPE_MD5;
7978 salt_type = SALT_TYPE_EMBEDDED;
7979 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7980 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7981 kern_type = KERN_TYPE_APR1CRYPT;
7982 dgst_size = DGST_SIZE_4_4;
7983 parse_func = md5apr1_parse_hash;
7984 sort_by_digest = sort_by_digest_4_4;
7985 opti_type = OPTI_TYPE_ZERO_BYTE;
7986 dgst_pos0 = 0;
7987 dgst_pos1 = 1;
7988 dgst_pos2 = 2;
7989 dgst_pos3 = 3;
7990 break;
7991
7992 case 1700: hash_type = HASH_TYPE_SHA512;
7993 salt_type = SALT_TYPE_NONE;
7994 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7995 opts_type = OPTS_TYPE_PT_GENERATE_BE
7996 | OPTS_TYPE_PT_ADD80
7997 | OPTS_TYPE_PT_ADDBITS15;
7998 kern_type = KERN_TYPE_SHA512;
7999 dgst_size = DGST_SIZE_8_8;
8000 parse_func = sha512_parse_hash;
8001 sort_by_digest = sort_by_digest_8_8;
8002 opti_type = OPTI_TYPE_ZERO_BYTE
8003 | OPTI_TYPE_PRECOMPUTE_INIT
8004 | OPTI_TYPE_PRECOMPUTE_MERKLE
8005 | OPTI_TYPE_EARLY_SKIP
8006 | OPTI_TYPE_NOT_ITERATED
8007 | OPTI_TYPE_NOT_SALTED
8008 | OPTI_TYPE_USES_BITS_64
8009 | OPTI_TYPE_RAW_HASH;
8010 dgst_pos0 = 14;
8011 dgst_pos1 = 15;
8012 dgst_pos2 = 6;
8013 dgst_pos3 = 7;
8014 break;
8015
8016 case 1710: hash_type = HASH_TYPE_SHA512;
8017 salt_type = SALT_TYPE_INTERN;
8018 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8019 opts_type = OPTS_TYPE_PT_GENERATE_BE
8020 | OPTS_TYPE_ST_ADD80
8021 | OPTS_TYPE_ST_ADDBITS15;
8022 kern_type = KERN_TYPE_SHA512_PWSLT;
8023 dgst_size = DGST_SIZE_8_8;
8024 parse_func = sha512s_parse_hash;
8025 sort_by_digest = sort_by_digest_8_8;
8026 opti_type = OPTI_TYPE_ZERO_BYTE
8027 | OPTI_TYPE_PRECOMPUTE_INIT
8028 | OPTI_TYPE_PRECOMPUTE_MERKLE
8029 | OPTI_TYPE_EARLY_SKIP
8030 | OPTI_TYPE_NOT_ITERATED
8031 | OPTI_TYPE_APPENDED_SALT
8032 | OPTI_TYPE_USES_BITS_64
8033 | OPTI_TYPE_RAW_HASH;
8034 dgst_pos0 = 14;
8035 dgst_pos1 = 15;
8036 dgst_pos2 = 6;
8037 dgst_pos3 = 7;
8038 break;
8039
8040 case 1711: hash_type = HASH_TYPE_SHA512;
8041 salt_type = SALT_TYPE_EMBEDDED;
8042 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8043 opts_type = OPTS_TYPE_PT_GENERATE_BE
8044 | OPTS_TYPE_ST_ADD80
8045 | OPTS_TYPE_ST_ADDBITS15;
8046 kern_type = KERN_TYPE_SHA512_PWSLT;
8047 dgst_size = DGST_SIZE_8_8;
8048 parse_func = sha512b64s_parse_hash;
8049 sort_by_digest = sort_by_digest_8_8;
8050 opti_type = OPTI_TYPE_ZERO_BYTE
8051 | OPTI_TYPE_PRECOMPUTE_INIT
8052 | OPTI_TYPE_PRECOMPUTE_MERKLE
8053 | OPTI_TYPE_EARLY_SKIP
8054 | OPTI_TYPE_NOT_ITERATED
8055 | OPTI_TYPE_APPENDED_SALT
8056 | OPTI_TYPE_USES_BITS_64
8057 | OPTI_TYPE_RAW_HASH;
8058 dgst_pos0 = 14;
8059 dgst_pos1 = 15;
8060 dgst_pos2 = 6;
8061 dgst_pos3 = 7;
8062 break;
8063
8064 case 1720: hash_type = HASH_TYPE_SHA512;
8065 salt_type = SALT_TYPE_INTERN;
8066 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8067 opts_type = OPTS_TYPE_PT_GENERATE_BE
8068 | OPTS_TYPE_PT_ADD80
8069 | OPTS_TYPE_PT_ADDBITS15;
8070 kern_type = KERN_TYPE_SHA512_SLTPW;
8071 dgst_size = DGST_SIZE_8_8;
8072 parse_func = sha512s_parse_hash;
8073 sort_by_digest = sort_by_digest_8_8;
8074 opti_type = OPTI_TYPE_ZERO_BYTE
8075 | OPTI_TYPE_PRECOMPUTE_INIT
8076 | OPTI_TYPE_PRECOMPUTE_MERKLE
8077 | OPTI_TYPE_EARLY_SKIP
8078 | OPTI_TYPE_NOT_ITERATED
8079 | OPTI_TYPE_PREPENDED_SALT
8080 | OPTI_TYPE_USES_BITS_64
8081 | OPTI_TYPE_RAW_HASH;
8082 dgst_pos0 = 14;
8083 dgst_pos1 = 15;
8084 dgst_pos2 = 6;
8085 dgst_pos3 = 7;
8086 break;
8087
8088 case 1722: hash_type = HASH_TYPE_SHA512;
8089 salt_type = SALT_TYPE_EMBEDDED;
8090 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8091 opts_type = OPTS_TYPE_PT_GENERATE_BE
8092 | OPTS_TYPE_PT_ADD80
8093 | OPTS_TYPE_PT_ADDBITS15
8094 | OPTS_TYPE_ST_HEX;
8095 kern_type = KERN_TYPE_SHA512_SLTPW;
8096 dgst_size = DGST_SIZE_8_8;
8097 parse_func = osx512_parse_hash;
8098 sort_by_digest = sort_by_digest_8_8;
8099 opti_type = OPTI_TYPE_ZERO_BYTE
8100 | OPTI_TYPE_PRECOMPUTE_INIT
8101 | OPTI_TYPE_PRECOMPUTE_MERKLE
8102 | OPTI_TYPE_EARLY_SKIP
8103 | OPTI_TYPE_NOT_ITERATED
8104 | OPTI_TYPE_PREPENDED_SALT
8105 | OPTI_TYPE_USES_BITS_64
8106 | OPTI_TYPE_RAW_HASH;
8107 dgst_pos0 = 14;
8108 dgst_pos1 = 15;
8109 dgst_pos2 = 6;
8110 dgst_pos3 = 7;
8111 break;
8112
8113 case 1730: hash_type = HASH_TYPE_SHA512;
8114 salt_type = SALT_TYPE_INTERN;
8115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8116 opts_type = OPTS_TYPE_PT_GENERATE_BE
8117 | OPTS_TYPE_PT_UNICODE
8118 | OPTS_TYPE_ST_ADD80
8119 | OPTS_TYPE_ST_ADDBITS15;
8120 kern_type = KERN_TYPE_SHA512_PWSLTU;
8121 dgst_size = DGST_SIZE_8_8;
8122 parse_func = sha512s_parse_hash;
8123 sort_by_digest = sort_by_digest_8_8;
8124 opti_type = OPTI_TYPE_ZERO_BYTE
8125 | OPTI_TYPE_PRECOMPUTE_INIT
8126 | OPTI_TYPE_PRECOMPUTE_MERKLE
8127 | OPTI_TYPE_EARLY_SKIP
8128 | OPTI_TYPE_NOT_ITERATED
8129 | OPTI_TYPE_APPENDED_SALT
8130 | OPTI_TYPE_USES_BITS_64
8131 | OPTI_TYPE_RAW_HASH;
8132 dgst_pos0 = 14;
8133 dgst_pos1 = 15;
8134 dgst_pos2 = 6;
8135 dgst_pos3 = 7;
8136 break;
8137
8138 case 1731: hash_type = HASH_TYPE_SHA512;
8139 salt_type = SALT_TYPE_EMBEDDED;
8140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8141 opts_type = OPTS_TYPE_PT_GENERATE_BE
8142 | OPTS_TYPE_PT_UNICODE
8143 | OPTS_TYPE_ST_ADD80
8144 | OPTS_TYPE_ST_ADDBITS15
8145 | OPTS_TYPE_ST_HEX;
8146 kern_type = KERN_TYPE_SHA512_PWSLTU;
8147 dgst_size = DGST_SIZE_8_8;
8148 parse_func = mssql2012_parse_hash;
8149 sort_by_digest = sort_by_digest_8_8;
8150 opti_type = OPTI_TYPE_ZERO_BYTE
8151 | OPTI_TYPE_PRECOMPUTE_INIT
8152 | OPTI_TYPE_PRECOMPUTE_MERKLE
8153 | OPTI_TYPE_EARLY_SKIP
8154 | OPTI_TYPE_NOT_ITERATED
8155 | OPTI_TYPE_APPENDED_SALT
8156 | OPTI_TYPE_USES_BITS_64
8157 | OPTI_TYPE_RAW_HASH;
8158 dgst_pos0 = 14;
8159 dgst_pos1 = 15;
8160 dgst_pos2 = 6;
8161 dgst_pos3 = 7;
8162 break;
8163
8164 case 1740: hash_type = HASH_TYPE_SHA512;
8165 salt_type = SALT_TYPE_INTERN;
8166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8167 opts_type = OPTS_TYPE_PT_GENERATE_BE
8168 | OPTS_TYPE_PT_ADD80
8169 | OPTS_TYPE_PT_ADDBITS15
8170 | OPTS_TYPE_PT_UNICODE;
8171 kern_type = KERN_TYPE_SHA512_SLTPWU;
8172 dgst_size = DGST_SIZE_8_8;
8173 parse_func = sha512s_parse_hash;
8174 sort_by_digest = sort_by_digest_8_8;
8175 opti_type = OPTI_TYPE_ZERO_BYTE
8176 | OPTI_TYPE_PRECOMPUTE_INIT
8177 | OPTI_TYPE_PRECOMPUTE_MERKLE
8178 | OPTI_TYPE_EARLY_SKIP
8179 | OPTI_TYPE_NOT_ITERATED
8180 | OPTI_TYPE_PREPENDED_SALT
8181 | OPTI_TYPE_USES_BITS_64
8182 | OPTI_TYPE_RAW_HASH;
8183 dgst_pos0 = 14;
8184 dgst_pos1 = 15;
8185 dgst_pos2 = 6;
8186 dgst_pos3 = 7;
8187 break;
8188
8189 case 1750: hash_type = HASH_TYPE_SHA512;
8190 salt_type = SALT_TYPE_INTERN;
8191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8192 opts_type = OPTS_TYPE_PT_GENERATE_BE
8193 | OPTS_TYPE_ST_ADD80;
8194 kern_type = KERN_TYPE_HMACSHA512_PW;
8195 dgst_size = DGST_SIZE_8_8;
8196 parse_func = hmacsha512_parse_hash;
8197 sort_by_digest = sort_by_digest_8_8;
8198 opti_type = OPTI_TYPE_ZERO_BYTE
8199 | OPTI_TYPE_USES_BITS_64
8200 | OPTI_TYPE_NOT_ITERATED;
8201 dgst_pos0 = 14;
8202 dgst_pos1 = 15;
8203 dgst_pos2 = 6;
8204 dgst_pos3 = 7;
8205 break;
8206
8207 case 1760: hash_type = HASH_TYPE_SHA512;
8208 salt_type = SALT_TYPE_INTERN;
8209 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8210 opts_type = OPTS_TYPE_PT_GENERATE_BE
8211 | OPTS_TYPE_PT_ADD80
8212 | OPTS_TYPE_PT_ADDBITS15;
8213 kern_type = KERN_TYPE_HMACSHA512_SLT;
8214 dgst_size = DGST_SIZE_8_8;
8215 parse_func = hmacsha512_parse_hash;
8216 sort_by_digest = sort_by_digest_8_8;
8217 opti_type = OPTI_TYPE_ZERO_BYTE
8218 | OPTI_TYPE_USES_BITS_64
8219 | OPTI_TYPE_NOT_ITERATED;
8220 dgst_pos0 = 14;
8221 dgst_pos1 = 15;
8222 dgst_pos2 = 6;
8223 dgst_pos3 = 7;
8224 break;
8225
8226 case 1800: hash_type = HASH_TYPE_SHA512;
8227 salt_type = SALT_TYPE_EMBEDDED;
8228 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8229 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8230 kern_type = KERN_TYPE_SHA512CRYPT;
8231 dgst_size = DGST_SIZE_8_8;
8232 parse_func = sha512crypt_parse_hash;
8233 sort_by_digest = sort_by_digest_8_8;
8234 opti_type = OPTI_TYPE_ZERO_BYTE
8235 | OPTI_TYPE_USES_BITS_64;
8236 dgst_pos0 = 0;
8237 dgst_pos1 = 1;
8238 dgst_pos2 = 2;
8239 dgst_pos3 = 3;
8240 break;
8241
8242 case 2100: hash_type = HASH_TYPE_DCC2;
8243 salt_type = SALT_TYPE_EMBEDDED;
8244 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8245 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8246 | OPTS_TYPE_ST_LOWER
8247 | OPTS_TYPE_ST_UNICODE;
8248 kern_type = KERN_TYPE_DCC2;
8249 dgst_size = DGST_SIZE_4_4;
8250 parse_func = dcc2_parse_hash;
8251 sort_by_digest = sort_by_digest_4_4;
8252 opti_type = OPTI_TYPE_ZERO_BYTE;
8253 dgst_pos0 = 0;
8254 dgst_pos1 = 1;
8255 dgst_pos2 = 2;
8256 dgst_pos3 = 3;
8257 break;
8258
8259 case 2400: hash_type = HASH_TYPE_MD5;
8260 salt_type = SALT_TYPE_NONE;
8261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8262 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8263 kern_type = KERN_TYPE_MD5PIX;
8264 dgst_size = DGST_SIZE_4_4;
8265 parse_func = md5pix_parse_hash;
8266 sort_by_digest = sort_by_digest_4_4;
8267 opti_type = OPTI_TYPE_ZERO_BYTE
8268 | OPTI_TYPE_PRECOMPUTE_INIT
8269 | OPTI_TYPE_PRECOMPUTE_MERKLE
8270 | OPTI_TYPE_EARLY_SKIP
8271 | OPTI_TYPE_NOT_ITERATED
8272 | OPTI_TYPE_NOT_SALTED;
8273 dgst_pos0 = 0;
8274 dgst_pos1 = 3;
8275 dgst_pos2 = 2;
8276 dgst_pos3 = 1;
8277 break;
8278
8279 case 2410: hash_type = HASH_TYPE_MD5;
8280 salt_type = SALT_TYPE_INTERN;
8281 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8282 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8283 kern_type = KERN_TYPE_MD5ASA;
8284 dgst_size = DGST_SIZE_4_4;
8285 parse_func = md5asa_parse_hash;
8286 sort_by_digest = sort_by_digest_4_4;
8287 opti_type = OPTI_TYPE_ZERO_BYTE
8288 | OPTI_TYPE_PRECOMPUTE_INIT
8289 | OPTI_TYPE_PRECOMPUTE_MERKLE
8290 | OPTI_TYPE_EARLY_SKIP
8291 | OPTI_TYPE_NOT_ITERATED;
8292 dgst_pos0 = 0;
8293 dgst_pos1 = 3;
8294 dgst_pos2 = 2;
8295 dgst_pos3 = 1;
8296 break;
8297
8298 case 2500: hash_type = HASH_TYPE_WPA;
8299 salt_type = SALT_TYPE_EMBEDDED;
8300 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8301 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8302 kern_type = KERN_TYPE_WPA;
8303 dgst_size = DGST_SIZE_4_4;
8304 parse_func = wpa_parse_hash;
8305 sort_by_digest = sort_by_digest_4_4;
8306 opti_type = OPTI_TYPE_ZERO_BYTE;
8307 dgst_pos0 = 0;
8308 dgst_pos1 = 1;
8309 dgst_pos2 = 2;
8310 dgst_pos3 = 3;
8311 break;
8312
8313 case 2600: hash_type = HASH_TYPE_MD5;
8314 salt_type = SALT_TYPE_VIRTUAL;
8315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8316 opts_type = OPTS_TYPE_PT_GENERATE_LE
8317 | OPTS_TYPE_PT_ADD80
8318 | OPTS_TYPE_PT_ADDBITS14
8319 | OPTS_TYPE_ST_ADD80;
8320 kern_type = KERN_TYPE_MD55_PWSLT1;
8321 dgst_size = DGST_SIZE_4_4;
8322 parse_func = md5md5_parse_hash;
8323 sort_by_digest = sort_by_digest_4_4;
8324 opti_type = OPTI_TYPE_ZERO_BYTE
8325 | OPTI_TYPE_PRECOMPUTE_INIT
8326 | OPTI_TYPE_PRECOMPUTE_MERKLE
8327 | OPTI_TYPE_EARLY_SKIP;
8328 dgst_pos0 = 0;
8329 dgst_pos1 = 3;
8330 dgst_pos2 = 2;
8331 dgst_pos3 = 1;
8332 break;
8333
8334 case 2611: hash_type = HASH_TYPE_MD5;
8335 salt_type = SALT_TYPE_INTERN;
8336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8337 opts_type = OPTS_TYPE_PT_GENERATE_LE
8338 | OPTS_TYPE_PT_ADD80
8339 | OPTS_TYPE_PT_ADDBITS14
8340 | OPTS_TYPE_ST_ADD80;
8341 kern_type = KERN_TYPE_MD55_PWSLT1;
8342 dgst_size = DGST_SIZE_4_4;
8343 parse_func = vb3_parse_hash;
8344 sort_by_digest = sort_by_digest_4_4;
8345 opti_type = OPTI_TYPE_ZERO_BYTE
8346 | OPTI_TYPE_PRECOMPUTE_INIT
8347 | OPTI_TYPE_PRECOMPUTE_MERKLE
8348 | OPTI_TYPE_EARLY_SKIP;
8349 dgst_pos0 = 0;
8350 dgst_pos1 = 3;
8351 dgst_pos2 = 2;
8352 dgst_pos3 = 1;
8353 break;
8354
8355 case 2612: hash_type = HASH_TYPE_MD5;
8356 salt_type = SALT_TYPE_EMBEDDED;
8357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8358 opts_type = OPTS_TYPE_PT_GENERATE_LE
8359 | OPTS_TYPE_PT_ADD80
8360 | OPTS_TYPE_PT_ADDBITS14
8361 | OPTS_TYPE_ST_ADD80
8362 | OPTS_TYPE_ST_HEX;
8363 kern_type = KERN_TYPE_MD55_PWSLT1;
8364 dgst_size = DGST_SIZE_4_4;
8365 parse_func = phps_parse_hash;
8366 sort_by_digest = sort_by_digest_4_4;
8367 opti_type = OPTI_TYPE_ZERO_BYTE
8368 | OPTI_TYPE_PRECOMPUTE_INIT
8369 | OPTI_TYPE_PRECOMPUTE_MERKLE
8370 | OPTI_TYPE_EARLY_SKIP;
8371 dgst_pos0 = 0;
8372 dgst_pos1 = 3;
8373 dgst_pos2 = 2;
8374 dgst_pos3 = 1;
8375 break;
8376
8377 case 2711: hash_type = HASH_TYPE_MD5;
8378 salt_type = SALT_TYPE_INTERN;
8379 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8380 opts_type = OPTS_TYPE_PT_GENERATE_LE
8381 | OPTS_TYPE_PT_ADD80
8382 | OPTS_TYPE_PT_ADDBITS14
8383 | OPTS_TYPE_ST_ADD80;
8384 kern_type = KERN_TYPE_MD55_PWSLT2;
8385 dgst_size = DGST_SIZE_4_4;
8386 parse_func = vb30_parse_hash;
8387 sort_by_digest = sort_by_digest_4_4;
8388 opti_type = OPTI_TYPE_ZERO_BYTE
8389 | OPTI_TYPE_PRECOMPUTE_INIT
8390 | OPTI_TYPE_EARLY_SKIP;
8391 dgst_pos0 = 0;
8392 dgst_pos1 = 3;
8393 dgst_pos2 = 2;
8394 dgst_pos3 = 1;
8395 break;
8396
8397 case 2811: hash_type = HASH_TYPE_MD5;
8398 salt_type = SALT_TYPE_INTERN;
8399 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8400 opts_type = OPTS_TYPE_PT_GENERATE_LE
8401 | OPTS_TYPE_PT_ADD80
8402 | OPTS_TYPE_PT_ADDBITS14;
8403 kern_type = KERN_TYPE_MD55_SLTPW;
8404 dgst_size = DGST_SIZE_4_4;
8405 parse_func = ipb2_parse_hash;
8406 sort_by_digest = sort_by_digest_4_4;
8407 opti_type = OPTI_TYPE_ZERO_BYTE
8408 | OPTI_TYPE_PRECOMPUTE_INIT
8409 | OPTI_TYPE_EARLY_SKIP;
8410 dgst_pos0 = 0;
8411 dgst_pos1 = 3;
8412 dgst_pos2 = 2;
8413 dgst_pos3 = 1;
8414 break;
8415
8416 case 3000: hash_type = HASH_TYPE_LM;
8417 salt_type = SALT_TYPE_NONE;
8418 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8419 opts_type = OPTS_TYPE_PT_GENERATE_LE
8420 | OPTS_TYPE_PT_UPPER
8421 | OPTS_TYPE_PT_BITSLICE;
8422 kern_type = KERN_TYPE_LM;
8423 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8424 parse_func = lm_parse_hash;
8425 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8426 opti_type = OPTI_TYPE_ZERO_BYTE
8427 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8428 dgst_pos0 = 0;
8429 dgst_pos1 = 1;
8430 dgst_pos2 = 2;
8431 dgst_pos3 = 3;
8432 break;
8433
8434 case 3100: hash_type = HASH_TYPE_ORACLEH;
8435 salt_type = SALT_TYPE_INTERN;
8436 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8437 opts_type = OPTS_TYPE_PT_GENERATE_LE
8438 | OPTS_TYPE_PT_UPPER
8439 | OPTS_TYPE_ST_UPPER;
8440 kern_type = KERN_TYPE_ORACLEH;
8441 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8442 parse_func = oracleh_parse_hash;
8443 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8444 opti_type = OPTI_TYPE_ZERO_BYTE;
8445 dgst_pos0 = 0;
8446 dgst_pos1 = 1;
8447 dgst_pos2 = 2;
8448 dgst_pos3 = 3;
8449 break;
8450
8451 case 3200: hash_type = HASH_TYPE_BCRYPT;
8452 salt_type = SALT_TYPE_EMBEDDED;
8453 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8454 opts_type = OPTS_TYPE_PT_GENERATE_LE
8455 | OPTS_TYPE_ST_GENERATE_LE;
8456 kern_type = KERN_TYPE_BCRYPT;
8457 dgst_size = DGST_SIZE_4_6;
8458 parse_func = bcrypt_parse_hash;
8459 sort_by_digest = sort_by_digest_4_6;
8460 opti_type = OPTI_TYPE_ZERO_BYTE;
8461 dgst_pos0 = 0;
8462 dgst_pos1 = 1;
8463 dgst_pos2 = 2;
8464 dgst_pos3 = 3;
8465 break;
8466
8467 case 3710: hash_type = HASH_TYPE_MD5;
8468 salt_type = SALT_TYPE_INTERN;
8469 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8470 opts_type = OPTS_TYPE_PT_GENERATE_LE
8471 | OPTS_TYPE_PT_ADD80
8472 | OPTS_TYPE_PT_ADDBITS14;
8473 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8474 dgst_size = DGST_SIZE_4_4;
8475 parse_func = md5s_parse_hash;
8476 sort_by_digest = sort_by_digest_4_4;
8477 opti_type = OPTI_TYPE_ZERO_BYTE
8478 | OPTI_TYPE_PRECOMPUTE_INIT
8479 | OPTI_TYPE_PRECOMPUTE_MERKLE
8480 | OPTI_TYPE_EARLY_SKIP;
8481 dgst_pos0 = 0;
8482 dgst_pos1 = 3;
8483 dgst_pos2 = 2;
8484 dgst_pos3 = 1;
8485 break;
8486
8487 case 3711: hash_type = HASH_TYPE_MD5;
8488 salt_type = SALT_TYPE_EMBEDDED;
8489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8490 opts_type = OPTS_TYPE_PT_GENERATE_LE
8491 | OPTS_TYPE_PT_ADD80
8492 | OPTS_TYPE_PT_ADDBITS14;
8493 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8494 dgst_size = DGST_SIZE_4_4;
8495 parse_func = mediawiki_b_parse_hash;
8496 sort_by_digest = sort_by_digest_4_4;
8497 opti_type = OPTI_TYPE_ZERO_BYTE
8498 | OPTI_TYPE_PRECOMPUTE_INIT
8499 | OPTI_TYPE_PRECOMPUTE_MERKLE
8500 | OPTI_TYPE_EARLY_SKIP;
8501 dgst_pos0 = 0;
8502 dgst_pos1 = 3;
8503 dgst_pos2 = 2;
8504 dgst_pos3 = 1;
8505 break;
8506
8507 case 3800: hash_type = HASH_TYPE_MD5;
8508 salt_type = SALT_TYPE_INTERN;
8509 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8510 opts_type = OPTS_TYPE_PT_GENERATE_LE
8511 | OPTS_TYPE_ST_ADDBITS14;
8512 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8513 dgst_size = DGST_SIZE_4_4;
8514 parse_func = md5s_parse_hash;
8515 sort_by_digest = sort_by_digest_4_4;
8516 opti_type = OPTI_TYPE_ZERO_BYTE
8517 | OPTI_TYPE_PRECOMPUTE_INIT
8518 | OPTI_TYPE_PRECOMPUTE_MERKLE
8519 | OPTI_TYPE_EARLY_SKIP
8520 | OPTI_TYPE_NOT_ITERATED
8521 | OPTI_TYPE_RAW_HASH;
8522 dgst_pos0 = 0;
8523 dgst_pos1 = 3;
8524 dgst_pos2 = 2;
8525 dgst_pos3 = 1;
8526 break;
8527
8528 case 4300: hash_type = HASH_TYPE_MD5;
8529 salt_type = SALT_TYPE_VIRTUAL;
8530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8531 opts_type = OPTS_TYPE_PT_GENERATE_LE
8532 | OPTS_TYPE_PT_ADD80
8533 | OPTS_TYPE_PT_ADDBITS14
8534 | OPTS_TYPE_ST_ADD80;
8535 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8536 dgst_size = DGST_SIZE_4_4;
8537 parse_func = md5md5_parse_hash;
8538 sort_by_digest = sort_by_digest_4_4;
8539 opti_type = OPTI_TYPE_ZERO_BYTE
8540 | OPTI_TYPE_PRECOMPUTE_INIT
8541 | OPTI_TYPE_PRECOMPUTE_MERKLE
8542 | OPTI_TYPE_EARLY_SKIP;
8543 dgst_pos0 = 0;
8544 dgst_pos1 = 3;
8545 dgst_pos2 = 2;
8546 dgst_pos3 = 1;
8547 break;
8548
8549
8550 case 4400: hash_type = HASH_TYPE_MD5;
8551 salt_type = SALT_TYPE_NONE;
8552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8553 opts_type = OPTS_TYPE_PT_GENERATE_BE
8554 | OPTS_TYPE_PT_ADD80
8555 | OPTS_TYPE_PT_ADDBITS15;
8556 kern_type = KERN_TYPE_MD5_SHA1;
8557 dgst_size = DGST_SIZE_4_4;
8558 parse_func = md5_parse_hash;
8559 sort_by_digest = sort_by_digest_4_4;
8560 opti_type = OPTI_TYPE_ZERO_BYTE
8561 | OPTI_TYPE_PRECOMPUTE_INIT
8562 | OPTI_TYPE_PRECOMPUTE_MERKLE
8563 | OPTI_TYPE_EARLY_SKIP
8564 | OPTI_TYPE_NOT_ITERATED
8565 | OPTI_TYPE_NOT_SALTED
8566 | OPTI_TYPE_RAW_HASH;
8567 dgst_pos0 = 0;
8568 dgst_pos1 = 3;
8569 dgst_pos2 = 2;
8570 dgst_pos3 = 1;
8571 break;
8572
8573 case 4500: hash_type = HASH_TYPE_SHA1;
8574 salt_type = SALT_TYPE_NONE;
8575 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8576 opts_type = OPTS_TYPE_PT_GENERATE_BE
8577 | OPTS_TYPE_PT_ADD80
8578 | OPTS_TYPE_PT_ADDBITS15;
8579 kern_type = KERN_TYPE_SHA11;
8580 dgst_size = DGST_SIZE_4_5;
8581 parse_func = sha1_parse_hash;
8582 sort_by_digest = sort_by_digest_4_5;
8583 opti_type = OPTI_TYPE_ZERO_BYTE
8584 | OPTI_TYPE_PRECOMPUTE_INIT
8585 | OPTI_TYPE_PRECOMPUTE_MERKLE
8586 | OPTI_TYPE_EARLY_SKIP
8587 | OPTI_TYPE_NOT_SALTED;
8588 dgst_pos0 = 3;
8589 dgst_pos1 = 4;
8590 dgst_pos2 = 2;
8591 dgst_pos3 = 1;
8592 break;
8593
8594 case 4700: hash_type = HASH_TYPE_SHA1;
8595 salt_type = SALT_TYPE_NONE;
8596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8597 opts_type = OPTS_TYPE_PT_GENERATE_LE
8598 | OPTS_TYPE_PT_ADD80
8599 | OPTS_TYPE_PT_ADDBITS14;
8600 kern_type = KERN_TYPE_SHA1_MD5;
8601 dgst_size = DGST_SIZE_4_5;
8602 parse_func = sha1_parse_hash;
8603 sort_by_digest = sort_by_digest_4_5;
8604 opti_type = OPTI_TYPE_ZERO_BYTE
8605 | OPTI_TYPE_PRECOMPUTE_INIT
8606 | OPTI_TYPE_PRECOMPUTE_MERKLE
8607 | OPTI_TYPE_EARLY_SKIP
8608 | OPTI_TYPE_NOT_ITERATED
8609 | OPTI_TYPE_NOT_SALTED
8610 | OPTI_TYPE_RAW_HASH;
8611 dgst_pos0 = 3;
8612 dgst_pos1 = 4;
8613 dgst_pos2 = 2;
8614 dgst_pos3 = 1;
8615 break;
8616
8617 case 4800: hash_type = HASH_TYPE_MD5;
8618 salt_type = SALT_TYPE_EMBEDDED;
8619 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8620 opts_type = OPTS_TYPE_PT_GENERATE_LE
8621 | OPTS_TYPE_PT_ADDBITS14;
8622 kern_type = KERN_TYPE_MD5_CHAP;
8623 dgst_size = DGST_SIZE_4_4;
8624 parse_func = chap_parse_hash;
8625 sort_by_digest = sort_by_digest_4_4;
8626 opti_type = OPTI_TYPE_ZERO_BYTE
8627 | OPTI_TYPE_PRECOMPUTE_INIT
8628 | OPTI_TYPE_PRECOMPUTE_MERKLE
8629 | OPTI_TYPE_MEET_IN_MIDDLE
8630 | OPTI_TYPE_EARLY_SKIP
8631 | OPTI_TYPE_NOT_ITERATED
8632 | OPTI_TYPE_RAW_HASH;
8633 dgst_pos0 = 0;
8634 dgst_pos1 = 3;
8635 dgst_pos2 = 2;
8636 dgst_pos3 = 1;
8637 break;
8638
8639 case 4900: hash_type = HASH_TYPE_SHA1;
8640 salt_type = SALT_TYPE_INTERN;
8641 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8642 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8643 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8644 dgst_size = DGST_SIZE_4_5;
8645 parse_func = sha1s_parse_hash;
8646 sort_by_digest = sort_by_digest_4_5;
8647 opti_type = OPTI_TYPE_ZERO_BYTE
8648 | OPTI_TYPE_PRECOMPUTE_INIT
8649 | OPTI_TYPE_PRECOMPUTE_MERKLE
8650 | OPTI_TYPE_EARLY_SKIP;
8651 dgst_pos0 = 3;
8652 dgst_pos1 = 4;
8653 dgst_pos2 = 2;
8654 dgst_pos3 = 1;
8655 break;
8656
8657 case 5000: hash_type = HASH_TYPE_KECCAK;
8658 salt_type = SALT_TYPE_EMBEDDED;
8659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8660 opts_type = OPTS_TYPE_PT_GENERATE_LE
8661 | OPTS_TYPE_PT_ADD01;
8662 kern_type = KERN_TYPE_KECCAK;
8663 dgst_size = DGST_SIZE_8_25;
8664 parse_func = keccak_parse_hash;
8665 sort_by_digest = sort_by_digest_8_25;
8666 opti_type = OPTI_TYPE_ZERO_BYTE
8667 | OPTI_TYPE_USES_BITS_64
8668 | OPTI_TYPE_RAW_HASH;
8669 dgst_pos0 = 2;
8670 dgst_pos1 = 3;
8671 dgst_pos2 = 4;
8672 dgst_pos3 = 5;
8673 break;
8674
8675 case 5100: hash_type = HASH_TYPE_MD5H;
8676 salt_type = SALT_TYPE_NONE;
8677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8678 opts_type = OPTS_TYPE_PT_GENERATE_LE
8679 | OPTS_TYPE_PT_ADD80
8680 | OPTS_TYPE_PT_ADDBITS14;
8681 kern_type = KERN_TYPE_MD5H;
8682 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8683 parse_func = md5half_parse_hash;
8684 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8685 opti_type = OPTI_TYPE_ZERO_BYTE
8686 | OPTI_TYPE_RAW_HASH;
8687 dgst_pos0 = 0;
8688 dgst_pos1 = 1;
8689 dgst_pos2 = 2;
8690 dgst_pos3 = 3;
8691 break;
8692
8693 case 5200: hash_type = HASH_TYPE_SHA256;
8694 salt_type = SALT_TYPE_EMBEDDED;
8695 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8696 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8697 kern_type = KERN_TYPE_PSAFE3;
8698 dgst_size = DGST_SIZE_4_8;
8699 parse_func = psafe3_parse_hash;
8700 sort_by_digest = sort_by_digest_4_8;
8701 opti_type = OPTI_TYPE_ZERO_BYTE;
8702 dgst_pos0 = 0;
8703 dgst_pos1 = 1;
8704 dgst_pos2 = 2;
8705 dgst_pos3 = 3;
8706 break;
8707
8708 case 5300: hash_type = HASH_TYPE_MD5;
8709 salt_type = SALT_TYPE_EMBEDDED;
8710 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8711 opts_type = OPTS_TYPE_PT_GENERATE_LE
8712 | OPTS_TYPE_ST_ADD80;
8713 kern_type = KERN_TYPE_IKEPSK_MD5;
8714 dgst_size = DGST_SIZE_4_4;
8715 parse_func = ikepsk_md5_parse_hash;
8716 sort_by_digest = sort_by_digest_4_4;
8717 opti_type = OPTI_TYPE_ZERO_BYTE;
8718 dgst_pos0 = 0;
8719 dgst_pos1 = 3;
8720 dgst_pos2 = 2;
8721 dgst_pos3 = 1;
8722 break;
8723
8724 case 5400: hash_type = HASH_TYPE_SHA1;
8725 salt_type = SALT_TYPE_EMBEDDED;
8726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8727 opts_type = OPTS_TYPE_PT_GENERATE_BE
8728 | OPTS_TYPE_ST_ADD80;
8729 kern_type = KERN_TYPE_IKEPSK_SHA1;
8730 dgst_size = DGST_SIZE_4_5;
8731 parse_func = ikepsk_sha1_parse_hash;
8732 sort_by_digest = sort_by_digest_4_5;
8733 opti_type = OPTI_TYPE_ZERO_BYTE;
8734 dgst_pos0 = 3;
8735 dgst_pos1 = 4;
8736 dgst_pos2 = 2;
8737 dgst_pos3 = 1;
8738 break;
8739
8740 case 5500: hash_type = HASH_TYPE_NETNTLM;
8741 salt_type = SALT_TYPE_EMBEDDED;
8742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8743 opts_type = OPTS_TYPE_PT_GENERATE_LE
8744 | OPTS_TYPE_PT_ADD80
8745 | OPTS_TYPE_PT_ADDBITS14
8746 | OPTS_TYPE_PT_UNICODE
8747 | OPTS_TYPE_ST_HEX;
8748 kern_type = KERN_TYPE_NETNTLMv1;
8749 dgst_size = DGST_SIZE_4_4;
8750 parse_func = netntlmv1_parse_hash;
8751 sort_by_digest = sort_by_digest_4_4;
8752 opti_type = OPTI_TYPE_ZERO_BYTE
8753 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8754 dgst_pos0 = 0;
8755 dgst_pos1 = 1;
8756 dgst_pos2 = 2;
8757 dgst_pos3 = 3;
8758 break;
8759
8760 case 5600: hash_type = HASH_TYPE_MD5;
8761 salt_type = SALT_TYPE_EMBEDDED;
8762 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8763 opts_type = OPTS_TYPE_PT_GENERATE_LE
8764 | OPTS_TYPE_PT_ADD80
8765 | OPTS_TYPE_PT_ADDBITS14
8766 | OPTS_TYPE_PT_UNICODE;
8767 kern_type = KERN_TYPE_NETNTLMv2;
8768 dgst_size = DGST_SIZE_4_4;
8769 parse_func = netntlmv2_parse_hash;
8770 sort_by_digest = sort_by_digest_4_4;
8771 opti_type = OPTI_TYPE_ZERO_BYTE;
8772 dgst_pos0 = 0;
8773 dgst_pos1 = 3;
8774 dgst_pos2 = 2;
8775 dgst_pos3 = 1;
8776 break;
8777
8778 case 5700: hash_type = HASH_TYPE_SHA256;
8779 salt_type = SALT_TYPE_NONE;
8780 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8781 opts_type = OPTS_TYPE_PT_GENERATE_BE
8782 | OPTS_TYPE_PT_ADD80
8783 | OPTS_TYPE_PT_ADDBITS15;
8784 kern_type = KERN_TYPE_SHA256;
8785 dgst_size = DGST_SIZE_4_8;
8786 parse_func = cisco4_parse_hash;
8787 sort_by_digest = sort_by_digest_4_8;
8788 opti_type = OPTI_TYPE_ZERO_BYTE
8789 | OPTI_TYPE_PRECOMPUTE_INIT
8790 | OPTI_TYPE_PRECOMPUTE_MERKLE
8791 | OPTI_TYPE_EARLY_SKIP
8792 | OPTI_TYPE_NOT_ITERATED
8793 | OPTI_TYPE_NOT_SALTED
8794 | OPTI_TYPE_RAW_HASH;
8795 dgst_pos0 = 3;
8796 dgst_pos1 = 7;
8797 dgst_pos2 = 2;
8798 dgst_pos3 = 6;
8799 break;
8800
8801 case 5800: hash_type = HASH_TYPE_SHA1;
8802 salt_type = SALT_TYPE_INTERN;
8803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8804 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8805 | OPTS_TYPE_ST_ADD80;
8806 kern_type = KERN_TYPE_ANDROIDPIN;
8807 dgst_size = DGST_SIZE_4_5;
8808 parse_func = androidpin_parse_hash;
8809 sort_by_digest = sort_by_digest_4_5;
8810 opti_type = OPTI_TYPE_ZERO_BYTE;
8811 dgst_pos0 = 0;
8812 dgst_pos1 = 1;
8813 dgst_pos2 = 2;
8814 dgst_pos3 = 3;
8815 break;
8816
8817 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8818 salt_type = SALT_TYPE_NONE;
8819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8820 opts_type = OPTS_TYPE_PT_GENERATE_LE
8821 | OPTS_TYPE_PT_ADD80;
8822 kern_type = KERN_TYPE_RIPEMD160;
8823 dgst_size = DGST_SIZE_4_5;
8824 parse_func = ripemd160_parse_hash;
8825 sort_by_digest = sort_by_digest_4_5;
8826 opti_type = OPTI_TYPE_ZERO_BYTE;
8827 dgst_pos0 = 0;
8828 dgst_pos1 = 1;
8829 dgst_pos2 = 2;
8830 dgst_pos3 = 3;
8831 break;
8832
8833 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8834 salt_type = SALT_TYPE_NONE;
8835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8836 opts_type = OPTS_TYPE_PT_GENERATE_BE
8837 | OPTS_TYPE_PT_ADD80;
8838 kern_type = KERN_TYPE_WHIRLPOOL;
8839 dgst_size = DGST_SIZE_4_16;
8840 parse_func = whirlpool_parse_hash;
8841 sort_by_digest = sort_by_digest_4_16;
8842 opti_type = OPTI_TYPE_ZERO_BYTE;
8843 dgst_pos0 = 0;
8844 dgst_pos1 = 1;
8845 dgst_pos2 = 2;
8846 dgst_pos3 = 3;
8847 break;
8848
8849 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8850 salt_type = SALT_TYPE_EMBEDDED;
8851 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8852 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8853 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8854 dgst_size = DGST_SIZE_4_5;
8855 parse_func = truecrypt_parse_hash_2k;
8856 sort_by_digest = sort_by_digest_4_5;
8857 opti_type = OPTI_TYPE_ZERO_BYTE;
8858 dgst_pos0 = 0;
8859 dgst_pos1 = 1;
8860 dgst_pos2 = 2;
8861 dgst_pos3 = 3;
8862 break;
8863
8864 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8865 salt_type = SALT_TYPE_EMBEDDED;
8866 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8867 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8868 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8869 dgst_size = DGST_SIZE_4_5;
8870 parse_func = truecrypt_parse_hash_2k;
8871 sort_by_digest = sort_by_digest_4_5;
8872 opti_type = OPTI_TYPE_ZERO_BYTE;
8873 dgst_pos0 = 0;
8874 dgst_pos1 = 1;
8875 dgst_pos2 = 2;
8876 dgst_pos3 = 3;
8877 break;
8878
8879 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8880 salt_type = SALT_TYPE_EMBEDDED;
8881 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8882 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8883 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8884 dgst_size = DGST_SIZE_4_5;
8885 parse_func = truecrypt_parse_hash_2k;
8886 sort_by_digest = sort_by_digest_4_5;
8887 opti_type = OPTI_TYPE_ZERO_BYTE;
8888 dgst_pos0 = 0;
8889 dgst_pos1 = 1;
8890 dgst_pos2 = 2;
8891 dgst_pos3 = 3;
8892 break;
8893
8894 case 6221: hash_type = HASH_TYPE_SHA512;
8895 salt_type = SALT_TYPE_EMBEDDED;
8896 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8897 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8898 kern_type = KERN_TYPE_TCSHA512_XTS512;
8899 dgst_size = DGST_SIZE_8_8;
8900 parse_func = truecrypt_parse_hash_1k;
8901 sort_by_digest = sort_by_digest_8_8;
8902 opti_type = OPTI_TYPE_ZERO_BYTE
8903 | OPTI_TYPE_USES_BITS_64;
8904 dgst_pos0 = 0;
8905 dgst_pos1 = 1;
8906 dgst_pos2 = 2;
8907 dgst_pos3 = 3;
8908 break;
8909
8910 case 6222: hash_type = HASH_TYPE_SHA512;
8911 salt_type = SALT_TYPE_EMBEDDED;
8912 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8913 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8914 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8915 dgst_size = DGST_SIZE_8_8;
8916 parse_func = truecrypt_parse_hash_1k;
8917 sort_by_digest = sort_by_digest_8_8;
8918 opti_type = OPTI_TYPE_ZERO_BYTE
8919 | OPTI_TYPE_USES_BITS_64;
8920 dgst_pos0 = 0;
8921 dgst_pos1 = 1;
8922 dgst_pos2 = 2;
8923 dgst_pos3 = 3;
8924 break;
8925
8926 case 6223: hash_type = HASH_TYPE_SHA512;
8927 salt_type = SALT_TYPE_EMBEDDED;
8928 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8929 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8930 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8931 dgst_size = DGST_SIZE_8_8;
8932 parse_func = truecrypt_parse_hash_1k;
8933 sort_by_digest = sort_by_digest_8_8;
8934 opti_type = OPTI_TYPE_ZERO_BYTE
8935 | OPTI_TYPE_USES_BITS_64;
8936 dgst_pos0 = 0;
8937 dgst_pos1 = 1;
8938 dgst_pos2 = 2;
8939 dgst_pos3 = 3;
8940 break;
8941
8942 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8943 salt_type = SALT_TYPE_EMBEDDED;
8944 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8945 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8946 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8947 dgst_size = DGST_SIZE_4_8;
8948 parse_func = truecrypt_parse_hash_1k;
8949 sort_by_digest = sort_by_digest_4_8;
8950 opti_type = OPTI_TYPE_ZERO_BYTE;
8951 dgst_pos0 = 0;
8952 dgst_pos1 = 1;
8953 dgst_pos2 = 2;
8954 dgst_pos3 = 3;
8955 break;
8956
8957 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8958 salt_type = SALT_TYPE_EMBEDDED;
8959 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8960 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8961 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8962 dgst_size = DGST_SIZE_4_8;
8963 parse_func = truecrypt_parse_hash_1k;
8964 sort_by_digest = sort_by_digest_4_8;
8965 opti_type = OPTI_TYPE_ZERO_BYTE;
8966 dgst_pos0 = 0;
8967 dgst_pos1 = 1;
8968 dgst_pos2 = 2;
8969 dgst_pos3 = 3;
8970 break;
8971
8972 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8973 salt_type = SALT_TYPE_EMBEDDED;
8974 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8975 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8976 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8977 dgst_size = DGST_SIZE_4_8;
8978 parse_func = truecrypt_parse_hash_1k;
8979 sort_by_digest = sort_by_digest_4_8;
8980 opti_type = OPTI_TYPE_ZERO_BYTE;
8981 dgst_pos0 = 0;
8982 dgst_pos1 = 1;
8983 dgst_pos2 = 2;
8984 dgst_pos3 = 3;
8985 break;
8986
8987 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8988 salt_type = SALT_TYPE_EMBEDDED;
8989 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8990 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8991 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8992 dgst_size = DGST_SIZE_4_5;
8993 parse_func = truecrypt_parse_hash_1k;
8994 sort_by_digest = sort_by_digest_4_5;
8995 opti_type = OPTI_TYPE_ZERO_BYTE;
8996 dgst_pos0 = 0;
8997 dgst_pos1 = 1;
8998 dgst_pos2 = 2;
8999 dgst_pos3 = 3;
9000 break;
9001
9002 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9003 salt_type = SALT_TYPE_EMBEDDED;
9004 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9005 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9006 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9007 dgst_size = DGST_SIZE_4_5;
9008 parse_func = truecrypt_parse_hash_1k;
9009 sort_by_digest = sort_by_digest_4_5;
9010 opti_type = OPTI_TYPE_ZERO_BYTE;
9011 dgst_pos0 = 0;
9012 dgst_pos1 = 1;
9013 dgst_pos2 = 2;
9014 dgst_pos3 = 3;
9015 break;
9016
9017 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9018 salt_type = SALT_TYPE_EMBEDDED;
9019 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9020 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9021 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9022 dgst_size = DGST_SIZE_4_5;
9023 parse_func = truecrypt_parse_hash_1k;
9024 sort_by_digest = sort_by_digest_4_5;
9025 opti_type = OPTI_TYPE_ZERO_BYTE;
9026 dgst_pos0 = 0;
9027 dgst_pos1 = 1;
9028 dgst_pos2 = 2;
9029 dgst_pos3 = 3;
9030 break;
9031
9032 case 6300: hash_type = HASH_TYPE_MD5;
9033 salt_type = SALT_TYPE_EMBEDDED;
9034 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9035 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9036 kern_type = KERN_TYPE_MD5AIX;
9037 dgst_size = DGST_SIZE_4_4;
9038 parse_func = md5aix_parse_hash;
9039 sort_by_digest = sort_by_digest_4_4;
9040 opti_type = OPTI_TYPE_ZERO_BYTE;
9041 dgst_pos0 = 0;
9042 dgst_pos1 = 1;
9043 dgst_pos2 = 2;
9044 dgst_pos3 = 3;
9045 break;
9046
9047 case 6400: hash_type = HASH_TYPE_SHA256;
9048 salt_type = SALT_TYPE_EMBEDDED;
9049 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9050 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9051 kern_type = KERN_TYPE_SHA256AIX;
9052 dgst_size = DGST_SIZE_4_8;
9053 parse_func = sha256aix_parse_hash;
9054 sort_by_digest = sort_by_digest_4_8;
9055 opti_type = OPTI_TYPE_ZERO_BYTE;
9056 dgst_pos0 = 0;
9057 dgst_pos1 = 1;
9058 dgst_pos2 = 2;
9059 dgst_pos3 = 3;
9060 break;
9061
9062 case 6500: hash_type = HASH_TYPE_SHA512;
9063 salt_type = SALT_TYPE_EMBEDDED;
9064 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9065 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9066 kern_type = KERN_TYPE_SHA512AIX;
9067 dgst_size = DGST_SIZE_8_8;
9068 parse_func = sha512aix_parse_hash;
9069 sort_by_digest = sort_by_digest_8_8;
9070 opti_type = OPTI_TYPE_ZERO_BYTE
9071 | OPTI_TYPE_USES_BITS_64;
9072 dgst_pos0 = 0;
9073 dgst_pos1 = 1;
9074 dgst_pos2 = 2;
9075 dgst_pos3 = 3;
9076 break;
9077
9078 case 6600: hash_type = HASH_TYPE_AES;
9079 salt_type = SALT_TYPE_EMBEDDED;
9080 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9081 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9082 kern_type = KERN_TYPE_AGILEKEY;
9083 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9084 parse_func = agilekey_parse_hash;
9085 sort_by_digest = sort_by_digest_4_5;
9086 opti_type = OPTI_TYPE_ZERO_BYTE;
9087 dgst_pos0 = 0;
9088 dgst_pos1 = 1;
9089 dgst_pos2 = 2;
9090 dgst_pos3 = 3;
9091 break;
9092
9093 case 6700: hash_type = HASH_TYPE_SHA1;
9094 salt_type = SALT_TYPE_EMBEDDED;
9095 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9096 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9097 kern_type = KERN_TYPE_SHA1AIX;
9098 dgst_size = DGST_SIZE_4_5;
9099 parse_func = sha1aix_parse_hash;
9100 sort_by_digest = sort_by_digest_4_5;
9101 opti_type = OPTI_TYPE_ZERO_BYTE;
9102 dgst_pos0 = 0;
9103 dgst_pos1 = 1;
9104 dgst_pos2 = 2;
9105 dgst_pos3 = 3;
9106 break;
9107
9108 case 6800: hash_type = HASH_TYPE_AES;
9109 salt_type = SALT_TYPE_EMBEDDED;
9110 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9111 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9112 kern_type = KERN_TYPE_LASTPASS;
9113 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9114 parse_func = lastpass_parse_hash;
9115 sort_by_digest = sort_by_digest_4_8;
9116 opti_type = OPTI_TYPE_ZERO_BYTE;
9117 dgst_pos0 = 0;
9118 dgst_pos1 = 1;
9119 dgst_pos2 = 2;
9120 dgst_pos3 = 3;
9121 break;
9122
9123 case 6900: hash_type = HASH_TYPE_GOST;
9124 salt_type = SALT_TYPE_NONE;
9125 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9126 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9127 kern_type = KERN_TYPE_GOST;
9128 dgst_size = DGST_SIZE_4_8;
9129 parse_func = gost_parse_hash;
9130 sort_by_digest = sort_by_digest_4_8;
9131 opti_type = OPTI_TYPE_ZERO_BYTE;
9132 dgst_pos0 = 0;
9133 dgst_pos1 = 1;
9134 dgst_pos2 = 2;
9135 dgst_pos3 = 3;
9136 break;
9137
9138 case 7100: hash_type = HASH_TYPE_SHA512;
9139 salt_type = SALT_TYPE_EMBEDDED;
9140 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9141 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9142 kern_type = KERN_TYPE_PBKDF2_SHA512;
9143 dgst_size = DGST_SIZE_8_16;
9144 parse_func = sha512osx_parse_hash;
9145 sort_by_digest = sort_by_digest_8_16;
9146 opti_type = OPTI_TYPE_ZERO_BYTE
9147 | OPTI_TYPE_USES_BITS_64;
9148 dgst_pos0 = 0;
9149 dgst_pos1 = 1;
9150 dgst_pos2 = 2;
9151 dgst_pos3 = 3;
9152 break;
9153
9154 case 7200: hash_type = HASH_TYPE_SHA512;
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_PBKDF2_SHA512;
9159 dgst_size = DGST_SIZE_8_16;
9160 parse_func = sha512grub_parse_hash;
9161 sort_by_digest = sort_by_digest_8_16;
9162 opti_type = OPTI_TYPE_ZERO_BYTE
9163 | OPTI_TYPE_USES_BITS_64;
9164 dgst_pos0 = 0;
9165 dgst_pos1 = 1;
9166 dgst_pos2 = 2;
9167 dgst_pos3 = 3;
9168 break;
9169
9170 case 7300: hash_type = HASH_TYPE_SHA1;
9171 salt_type = SALT_TYPE_EMBEDDED;
9172 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9173 opts_type = OPTS_TYPE_PT_GENERATE_BE
9174 | OPTS_TYPE_ST_ADD80
9175 | OPTS_TYPE_ST_ADDBITS15;
9176 kern_type = KERN_TYPE_RAKP;
9177 dgst_size = DGST_SIZE_4_5;
9178 parse_func = rakp_parse_hash;
9179 sort_by_digest = sort_by_digest_4_5;
9180 opti_type = OPTI_TYPE_ZERO_BYTE
9181 | OPTI_TYPE_NOT_ITERATED;
9182 dgst_pos0 = 3;
9183 dgst_pos1 = 4;
9184 dgst_pos2 = 2;
9185 dgst_pos3 = 1;
9186 break;
9187
9188 case 7400: hash_type = HASH_TYPE_SHA256;
9189 salt_type = SALT_TYPE_EMBEDDED;
9190 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9191 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9192 kern_type = KERN_TYPE_SHA256CRYPT;
9193 dgst_size = DGST_SIZE_4_8;
9194 parse_func = sha256crypt_parse_hash;
9195 sort_by_digest = sort_by_digest_4_8;
9196 opti_type = OPTI_TYPE_ZERO_BYTE;
9197 dgst_pos0 = 0;
9198 dgst_pos1 = 1;
9199 dgst_pos2 = 2;
9200 dgst_pos3 = 3;
9201 break;
9202
9203 case 7500: hash_type = HASH_TYPE_KRB5PA;
9204 salt_type = SALT_TYPE_EMBEDDED;
9205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9206 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9207 kern_type = KERN_TYPE_KRB5PA;
9208 dgst_size = DGST_SIZE_4_4;
9209 parse_func = krb5pa_parse_hash;
9210 sort_by_digest = sort_by_digest_4_4;
9211 opti_type = OPTI_TYPE_ZERO_BYTE
9212 | OPTI_TYPE_NOT_ITERATED;
9213 dgst_pos0 = 0;
9214 dgst_pos1 = 1;
9215 dgst_pos2 = 2;
9216 dgst_pos3 = 3;
9217 break;
9218
9219 case 7600: hash_type = HASH_TYPE_SHA1;
9220 salt_type = SALT_TYPE_INTERN;
9221 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9222 opts_type = OPTS_TYPE_PT_GENERATE_BE
9223 | OPTS_TYPE_PT_ADD80
9224 | OPTS_TYPE_PT_ADDBITS15;
9225 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9226 dgst_size = DGST_SIZE_4_5;
9227 parse_func = redmine_parse_hash;
9228 sort_by_digest = sort_by_digest_4_5;
9229 opti_type = OPTI_TYPE_ZERO_BYTE
9230 | OPTI_TYPE_PRECOMPUTE_INIT
9231 | OPTI_TYPE_EARLY_SKIP
9232 | OPTI_TYPE_NOT_ITERATED
9233 | OPTI_TYPE_PREPENDED_SALT;
9234 dgst_pos0 = 3;
9235 dgst_pos1 = 4;
9236 dgst_pos2 = 2;
9237 dgst_pos3 = 1;
9238 break;
9239
9240 case 7700: hash_type = HASH_TYPE_SAPB;
9241 salt_type = SALT_TYPE_EMBEDDED;
9242 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9243 opts_type = OPTS_TYPE_PT_GENERATE_LE
9244 | OPTS_TYPE_PT_UPPER
9245 | OPTS_TYPE_ST_UPPER;
9246 kern_type = KERN_TYPE_SAPB;
9247 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9248 parse_func = sapb_parse_hash;
9249 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9250 opti_type = OPTI_TYPE_ZERO_BYTE
9251 | OPTI_TYPE_PRECOMPUTE_INIT
9252 | OPTI_TYPE_NOT_ITERATED;
9253 dgst_pos0 = 0;
9254 dgst_pos1 = 1;
9255 dgst_pos2 = 2;
9256 dgst_pos3 = 3;
9257 break;
9258
9259 case 7800: hash_type = HASH_TYPE_SAPG;
9260 salt_type = SALT_TYPE_EMBEDDED;
9261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9262 opts_type = OPTS_TYPE_PT_GENERATE_BE
9263 | OPTS_TYPE_ST_ADD80
9264 | OPTS_TYPE_ST_UPPER;
9265 kern_type = KERN_TYPE_SAPG;
9266 dgst_size = DGST_SIZE_4_5;
9267 parse_func = sapg_parse_hash;
9268 sort_by_digest = sort_by_digest_4_5;
9269 opti_type = OPTI_TYPE_ZERO_BYTE
9270 | OPTI_TYPE_PRECOMPUTE_INIT
9271 | OPTI_TYPE_NOT_ITERATED;
9272 dgst_pos0 = 3;
9273 dgst_pos1 = 4;
9274 dgst_pos2 = 2;
9275 dgst_pos3 = 1;
9276 break;
9277
9278 case 7900: hash_type = HASH_TYPE_SHA512;
9279 salt_type = SALT_TYPE_EMBEDDED;
9280 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9281 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9282 kern_type = KERN_TYPE_DRUPAL7;
9283 dgst_size = DGST_SIZE_8_8;
9284 parse_func = drupal7_parse_hash;
9285 sort_by_digest = sort_by_digest_8_8;
9286 opti_type = OPTI_TYPE_ZERO_BYTE
9287 | OPTI_TYPE_USES_BITS_64;
9288 dgst_pos0 = 0;
9289 dgst_pos1 = 1;
9290 dgst_pos2 = 2;
9291 dgst_pos3 = 3;
9292 break;
9293
9294 case 8000: hash_type = HASH_TYPE_SHA256;
9295 salt_type = SALT_TYPE_EMBEDDED;
9296 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9297 opts_type = OPTS_TYPE_PT_GENERATE_BE
9298 | OPTS_TYPE_PT_UNICODE
9299 | OPTS_TYPE_ST_ADD80
9300 | OPTS_TYPE_ST_HEX;
9301 kern_type = KERN_TYPE_SYBASEASE;
9302 dgst_size = DGST_SIZE_4_8;
9303 parse_func = sybasease_parse_hash;
9304 sort_by_digest = sort_by_digest_4_8;
9305 opti_type = OPTI_TYPE_ZERO_BYTE
9306 | OPTI_TYPE_PRECOMPUTE_INIT
9307 | OPTI_TYPE_EARLY_SKIP
9308 | OPTI_TYPE_NOT_ITERATED
9309 | OPTI_TYPE_RAW_HASH;
9310 dgst_pos0 = 3;
9311 dgst_pos1 = 7;
9312 dgst_pos2 = 2;
9313 dgst_pos3 = 6;
9314 break;
9315
9316 case 8100: hash_type = HASH_TYPE_SHA1;
9317 salt_type = SALT_TYPE_EMBEDDED;
9318 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9319 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9320 kern_type = KERN_TYPE_NETSCALER;
9321 dgst_size = DGST_SIZE_4_5;
9322 parse_func = netscaler_parse_hash;
9323 sort_by_digest = sort_by_digest_4_5;
9324 opti_type = OPTI_TYPE_ZERO_BYTE
9325 | OPTI_TYPE_PRECOMPUTE_INIT
9326 | OPTI_TYPE_PRECOMPUTE_MERKLE
9327 | OPTI_TYPE_EARLY_SKIP
9328 | OPTI_TYPE_NOT_ITERATED
9329 | OPTI_TYPE_PREPENDED_SALT
9330 | OPTI_TYPE_RAW_HASH;
9331 dgst_pos0 = 3;
9332 dgst_pos1 = 4;
9333 dgst_pos2 = 2;
9334 dgst_pos3 = 1;
9335 break;
9336
9337 case 8200: hash_type = HASH_TYPE_SHA256;
9338 salt_type = SALT_TYPE_EMBEDDED;
9339 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9340 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9341 kern_type = KERN_TYPE_CLOUDKEY;
9342 dgst_size = DGST_SIZE_4_8;
9343 parse_func = cloudkey_parse_hash;
9344 sort_by_digest = sort_by_digest_4_8;
9345 opti_type = OPTI_TYPE_ZERO_BYTE;
9346 dgst_pos0 = 0;
9347 dgst_pos1 = 1;
9348 dgst_pos2 = 2;
9349 dgst_pos3 = 3;
9350 break;
9351
9352 case 8300: hash_type = HASH_TYPE_SHA1;
9353 salt_type = SALT_TYPE_EMBEDDED;
9354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9355 opts_type = OPTS_TYPE_PT_GENERATE_BE
9356 | OPTS_TYPE_ST_HEX
9357 | OPTS_TYPE_ST_ADD80;
9358 kern_type = KERN_TYPE_NSEC3;
9359 dgst_size = DGST_SIZE_4_5;
9360 parse_func = nsec3_parse_hash;
9361 sort_by_digest = sort_by_digest_4_5;
9362 opti_type = OPTI_TYPE_ZERO_BYTE;
9363 dgst_pos0 = 3;
9364 dgst_pos1 = 4;
9365 dgst_pos2 = 2;
9366 dgst_pos3 = 1;
9367 break;
9368
9369 case 8400: hash_type = HASH_TYPE_SHA1;
9370 salt_type = SALT_TYPE_INTERN;
9371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9372 opts_type = OPTS_TYPE_PT_GENERATE_BE
9373 | OPTS_TYPE_PT_ADD80
9374 | OPTS_TYPE_PT_ADDBITS15;
9375 kern_type = KERN_TYPE_WBB3;
9376 dgst_size = DGST_SIZE_4_5;
9377 parse_func = wbb3_parse_hash;
9378 sort_by_digest = sort_by_digest_4_5;
9379 opti_type = OPTI_TYPE_ZERO_BYTE
9380 | OPTI_TYPE_PRECOMPUTE_INIT
9381 | OPTI_TYPE_NOT_ITERATED;
9382 dgst_pos0 = 3;
9383 dgst_pos1 = 4;
9384 dgst_pos2 = 2;
9385 dgst_pos3 = 1;
9386 break;
9387
9388 case 8500: hash_type = HASH_TYPE_DESRACF;
9389 salt_type = SALT_TYPE_EMBEDDED;
9390 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9391 opts_type = OPTS_TYPE_PT_GENERATE_LE
9392 | OPTS_TYPE_ST_UPPER;
9393 kern_type = KERN_TYPE_RACF;
9394 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9395 parse_func = racf_parse_hash;
9396 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9397 opti_type = OPTI_TYPE_ZERO_BYTE
9398 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9399 dgst_pos0 = 0;
9400 dgst_pos1 = 1;
9401 dgst_pos2 = 2;
9402 dgst_pos3 = 3;
9403 break;
9404
9405 case 8600: hash_type = HASH_TYPE_LOTUS5;
9406 salt_type = SALT_TYPE_NONE;
9407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9408 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9409 kern_type = KERN_TYPE_LOTUS5;
9410 dgst_size = DGST_SIZE_4_4;
9411 parse_func = lotus5_parse_hash;
9412 sort_by_digest = sort_by_digest_4_4;
9413 opti_type = OPTI_TYPE_EARLY_SKIP
9414 | OPTI_TYPE_NOT_ITERATED
9415 | OPTI_TYPE_NOT_SALTED
9416 | OPTI_TYPE_RAW_HASH;
9417 dgst_pos0 = 0;
9418 dgst_pos1 = 1;
9419 dgst_pos2 = 2;
9420 dgst_pos3 = 3;
9421 break;
9422
9423 case 8700: hash_type = HASH_TYPE_LOTUS6;
9424 salt_type = SALT_TYPE_EMBEDDED;
9425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9426 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9427 kern_type = KERN_TYPE_LOTUS6;
9428 dgst_size = DGST_SIZE_4_4;
9429 parse_func = lotus6_parse_hash;
9430 sort_by_digest = sort_by_digest_4_4;
9431 opti_type = OPTI_TYPE_EARLY_SKIP
9432 | OPTI_TYPE_NOT_ITERATED
9433 | OPTI_TYPE_RAW_HASH;
9434 dgst_pos0 = 0;
9435 dgst_pos1 = 1;
9436 dgst_pos2 = 2;
9437 dgst_pos3 = 3;
9438 break;
9439
9440 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9441 salt_type = SALT_TYPE_EMBEDDED;
9442 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9443 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9444 kern_type = KERN_TYPE_ANDROIDFDE;
9445 dgst_size = DGST_SIZE_4_4;
9446 parse_func = androidfde_parse_hash;
9447 sort_by_digest = sort_by_digest_4_4;
9448 opti_type = OPTI_TYPE_ZERO_BYTE;
9449 dgst_pos0 = 0;
9450 dgst_pos1 = 1;
9451 dgst_pos2 = 2;
9452 dgst_pos3 = 3;
9453 break;
9454
9455 case 8900: hash_type = HASH_TYPE_SCRYPT;
9456 salt_type = SALT_TYPE_EMBEDDED;
9457 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9458 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9459 kern_type = KERN_TYPE_SCRYPT;
9460 dgst_size = DGST_SIZE_4_8;
9461 parse_func = scrypt_parse_hash;
9462 sort_by_digest = sort_by_digest_4_8;
9463 opti_type = OPTI_TYPE_ZERO_BYTE;
9464 dgst_pos0 = 0;
9465 dgst_pos1 = 1;
9466 dgst_pos2 = 2;
9467 dgst_pos3 = 3;
9468 break;
9469
9470 case 9000: hash_type = HASH_TYPE_SHA1;
9471 salt_type = SALT_TYPE_EMBEDDED;
9472 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9473 opts_type = OPTS_TYPE_PT_GENERATE_LE
9474 | OPTS_TYPE_ST_GENERATE_LE;
9475 kern_type = KERN_TYPE_PSAFE2;
9476 dgst_size = DGST_SIZE_4_5;
9477 parse_func = psafe2_parse_hash;
9478 sort_by_digest = sort_by_digest_4_5;
9479 opti_type = OPTI_TYPE_ZERO_BYTE;
9480 dgst_pos0 = 0;
9481 dgst_pos1 = 1;
9482 dgst_pos2 = 2;
9483 dgst_pos3 = 3;
9484 break;
9485
9486 case 9100: hash_type = HASH_TYPE_LOTUS8;
9487 salt_type = SALT_TYPE_EMBEDDED;
9488 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9489 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9490 kern_type = KERN_TYPE_LOTUS8;
9491 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9492 parse_func = lotus8_parse_hash;
9493 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9494 opti_type = OPTI_TYPE_ZERO_BYTE;
9495 dgst_pos0 = 0;
9496 dgst_pos1 = 1;
9497 dgst_pos2 = 2;
9498 dgst_pos3 = 3;
9499 break;
9500
9501 case 9200: hash_type = HASH_TYPE_SHA256;
9502 salt_type = SALT_TYPE_EMBEDDED;
9503 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9504 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9505 kern_type = KERN_TYPE_PBKDF2_SHA256;
9506 dgst_size = DGST_SIZE_4_32;
9507 parse_func = cisco8_parse_hash;
9508 sort_by_digest = sort_by_digest_4_32;
9509 opti_type = OPTI_TYPE_ZERO_BYTE;
9510 dgst_pos0 = 0;
9511 dgst_pos1 = 1;
9512 dgst_pos2 = 2;
9513 dgst_pos3 = 3;
9514 break;
9515
9516 case 9300: hash_type = HASH_TYPE_SCRYPT;
9517 salt_type = SALT_TYPE_EMBEDDED;
9518 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9519 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9520 kern_type = KERN_TYPE_SCRYPT;
9521 dgst_size = DGST_SIZE_4_8;
9522 parse_func = cisco9_parse_hash;
9523 sort_by_digest = sort_by_digest_4_8;
9524 opti_type = OPTI_TYPE_ZERO_BYTE;
9525 dgst_pos0 = 0;
9526 dgst_pos1 = 1;
9527 dgst_pos2 = 2;
9528 dgst_pos3 = 3;
9529 break;
9530
9531 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9532 salt_type = SALT_TYPE_EMBEDDED;
9533 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9534 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9535 kern_type = KERN_TYPE_OFFICE2007;
9536 dgst_size = DGST_SIZE_4_4;
9537 parse_func = office2007_parse_hash;
9538 sort_by_digest = sort_by_digest_4_4;
9539 opti_type = OPTI_TYPE_ZERO_BYTE;
9540 dgst_pos0 = 0;
9541 dgst_pos1 = 1;
9542 dgst_pos2 = 2;
9543 dgst_pos3 = 3;
9544 break;
9545
9546 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9547 salt_type = SALT_TYPE_EMBEDDED;
9548 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9549 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9550 kern_type = KERN_TYPE_OFFICE2010;
9551 dgst_size = DGST_SIZE_4_4;
9552 parse_func = office2010_parse_hash;
9553 sort_by_digest = sort_by_digest_4_4;
9554 opti_type = OPTI_TYPE_ZERO_BYTE;
9555 dgst_pos0 = 0;
9556 dgst_pos1 = 1;
9557 dgst_pos2 = 2;
9558 dgst_pos3 = 3;
9559 break;
9560
9561 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9562 salt_type = SALT_TYPE_EMBEDDED;
9563 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9564 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9565 kern_type = KERN_TYPE_OFFICE2013;
9566 dgst_size = DGST_SIZE_4_4;
9567 parse_func = office2013_parse_hash;
9568 sort_by_digest = sort_by_digest_4_4;
9569 opti_type = OPTI_TYPE_ZERO_BYTE;
9570 dgst_pos0 = 0;
9571 dgst_pos1 = 1;
9572 dgst_pos2 = 2;
9573 dgst_pos3 = 3;
9574 break;
9575
9576 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9577 salt_type = SALT_TYPE_EMBEDDED;
9578 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9579 opts_type = OPTS_TYPE_PT_GENERATE_LE
9580 | OPTS_TYPE_PT_ADD80
9581 | OPTS_TYPE_PT_UNICODE;
9582 kern_type = KERN_TYPE_OLDOFFICE01;
9583 dgst_size = DGST_SIZE_4_4;
9584 parse_func = oldoffice01_parse_hash;
9585 sort_by_digest = sort_by_digest_4_4;
9586 opti_type = OPTI_TYPE_ZERO_BYTE
9587 | OPTI_TYPE_PRECOMPUTE_INIT
9588 | OPTI_TYPE_NOT_ITERATED;
9589 dgst_pos0 = 0;
9590 dgst_pos1 = 1;
9591 dgst_pos2 = 2;
9592 dgst_pos3 = 3;
9593 break;
9594
9595 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9596 salt_type = SALT_TYPE_EMBEDDED;
9597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9598 opts_type = OPTS_TYPE_PT_GENERATE_LE
9599 | OPTS_TYPE_PT_ADD80;
9600 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9601 dgst_size = DGST_SIZE_4_4;
9602 parse_func = oldoffice01cm1_parse_hash;
9603 sort_by_digest = sort_by_digest_4_4;
9604 opti_type = OPTI_TYPE_ZERO_BYTE
9605 | OPTI_TYPE_PRECOMPUTE_INIT
9606 | OPTI_TYPE_NOT_ITERATED;
9607 dgst_pos0 = 0;
9608 dgst_pos1 = 1;
9609 dgst_pos2 = 2;
9610 dgst_pos3 = 3;
9611 break;
9612
9613 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9614 salt_type = SALT_TYPE_EMBEDDED;
9615 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9616 opts_type = OPTS_TYPE_PT_GENERATE_LE
9617 | OPTS_TYPE_PT_ADD80
9618 | OPTS_TYPE_PT_UNICODE
9619 | OPTS_TYPE_PT_NEVERCRACK;
9620 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9621 dgst_size = DGST_SIZE_4_4;
9622 parse_func = oldoffice01cm2_parse_hash;
9623 sort_by_digest = sort_by_digest_4_4;
9624 opti_type = OPTI_TYPE_ZERO_BYTE
9625 | OPTI_TYPE_PRECOMPUTE_INIT
9626 | OPTI_TYPE_NOT_ITERATED;
9627 dgst_pos0 = 0;
9628 dgst_pos1 = 1;
9629 dgst_pos2 = 2;
9630 dgst_pos3 = 3;
9631 break;
9632
9633 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9634 salt_type = SALT_TYPE_EMBEDDED;
9635 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9636 opts_type = OPTS_TYPE_PT_GENERATE_BE
9637 | OPTS_TYPE_PT_ADD80
9638 | OPTS_TYPE_PT_UNICODE;
9639 kern_type = KERN_TYPE_OLDOFFICE34;
9640 dgst_size = DGST_SIZE_4_4;
9641 parse_func = oldoffice34_parse_hash;
9642 sort_by_digest = sort_by_digest_4_4;
9643 opti_type = OPTI_TYPE_ZERO_BYTE
9644 | OPTI_TYPE_PRECOMPUTE_INIT
9645 | OPTI_TYPE_NOT_ITERATED;
9646 dgst_pos0 = 0;
9647 dgst_pos1 = 1;
9648 dgst_pos2 = 2;
9649 dgst_pos3 = 3;
9650 break;
9651
9652 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9653 salt_type = SALT_TYPE_EMBEDDED;
9654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9655 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9656 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9657 dgst_size = DGST_SIZE_4_4;
9658 parse_func = oldoffice34cm1_parse_hash;
9659 sort_by_digest = sort_by_digest_4_4;
9660 opti_type = OPTI_TYPE_ZERO_BYTE
9661 | OPTI_TYPE_PRECOMPUTE_INIT
9662 | OPTI_TYPE_NOT_ITERATED;
9663 dgst_pos0 = 0;
9664 dgst_pos1 = 1;
9665 dgst_pos2 = 2;
9666 dgst_pos3 = 3;
9667 break;
9668
9669 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9670 salt_type = SALT_TYPE_EMBEDDED;
9671 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9672 opts_type = OPTS_TYPE_PT_GENERATE_BE
9673 | OPTS_TYPE_PT_ADD80
9674 | OPTS_TYPE_PT_UNICODE
9675 | OPTS_TYPE_PT_NEVERCRACK;
9676 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9677 dgst_size = DGST_SIZE_4_4;
9678 parse_func = oldoffice34cm2_parse_hash;
9679 sort_by_digest = sort_by_digest_4_4;
9680 opti_type = OPTI_TYPE_ZERO_BYTE
9681 | OPTI_TYPE_PRECOMPUTE_INIT
9682 | OPTI_TYPE_NOT_ITERATED;
9683 dgst_pos0 = 0;
9684 dgst_pos1 = 1;
9685 dgst_pos2 = 2;
9686 dgst_pos3 = 3;
9687 break;
9688
9689 case 9900: hash_type = HASH_TYPE_MD5;
9690 salt_type = SALT_TYPE_NONE;
9691 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9692 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9693 kern_type = KERN_TYPE_RADMIN2;
9694 dgst_size = DGST_SIZE_4_4;
9695 parse_func = radmin2_parse_hash;
9696 sort_by_digest = sort_by_digest_4_4;
9697 opti_type = OPTI_TYPE_ZERO_BYTE
9698 | OPTI_TYPE_PRECOMPUTE_INIT
9699 | OPTI_TYPE_EARLY_SKIP
9700 | OPTI_TYPE_NOT_ITERATED
9701 | OPTI_TYPE_NOT_SALTED;
9702 dgst_pos0 = 0;
9703 dgst_pos1 = 3;
9704 dgst_pos2 = 2;
9705 dgst_pos3 = 1;
9706 break;
9707
9708 case 10000: hash_type = HASH_TYPE_SHA256;
9709 salt_type = SALT_TYPE_EMBEDDED;
9710 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9711 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9712 kern_type = KERN_TYPE_PBKDF2_SHA256;
9713 dgst_size = DGST_SIZE_4_32;
9714 parse_func = djangopbkdf2_parse_hash;
9715 sort_by_digest = sort_by_digest_4_32;
9716 opti_type = OPTI_TYPE_ZERO_BYTE;
9717 dgst_pos0 = 0;
9718 dgst_pos1 = 1;
9719 dgst_pos2 = 2;
9720 dgst_pos3 = 3;
9721 break;
9722
9723 case 10100: hash_type = HASH_TYPE_SIPHASH;
9724 salt_type = SALT_TYPE_EMBEDDED;
9725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9726 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9727 kern_type = KERN_TYPE_SIPHASH;
9728 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9729 parse_func = siphash_parse_hash;
9730 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9731 opti_type = OPTI_TYPE_ZERO_BYTE
9732 | OPTI_TYPE_NOT_ITERATED
9733 | OPTI_TYPE_RAW_HASH;
9734 dgst_pos0 = 0;
9735 dgst_pos1 = 1;
9736 dgst_pos2 = 2;
9737 dgst_pos3 = 3;
9738 break;
9739
9740 case 10200: hash_type = HASH_TYPE_MD5;
9741 salt_type = SALT_TYPE_EMBEDDED;
9742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9743 opts_type = OPTS_TYPE_PT_GENERATE_LE
9744 | OPTS_TYPE_ST_ADD80
9745 | OPTS_TYPE_ST_ADDBITS14;
9746 kern_type = KERN_TYPE_HMACMD5_PW;
9747 dgst_size = DGST_SIZE_4_4;
9748 parse_func = crammd5_parse_hash;
9749 sort_by_digest = sort_by_digest_4_4;
9750 opti_type = OPTI_TYPE_ZERO_BYTE
9751 | OPTI_TYPE_NOT_ITERATED;
9752 dgst_pos0 = 0;
9753 dgst_pos1 = 3;
9754 dgst_pos2 = 2;
9755 dgst_pos3 = 1;
9756 break;
9757
9758 case 10300: hash_type = HASH_TYPE_SHA1;
9759 salt_type = SALT_TYPE_EMBEDDED;
9760 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9761 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9762 kern_type = KERN_TYPE_SAPH_SHA1;
9763 dgst_size = DGST_SIZE_4_5;
9764 parse_func = saph_sha1_parse_hash;
9765 sort_by_digest = sort_by_digest_4_5;
9766 opti_type = OPTI_TYPE_ZERO_BYTE;
9767 dgst_pos0 = 0;
9768 dgst_pos1 = 1;
9769 dgst_pos2 = 2;
9770 dgst_pos3 = 3;
9771 break;
9772
9773 case 10400: hash_type = HASH_TYPE_PDFU16;
9774 salt_type = SALT_TYPE_EMBEDDED;
9775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9776 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9777 kern_type = KERN_TYPE_PDF11;
9778 dgst_size = DGST_SIZE_4_4;
9779 parse_func = pdf11_parse_hash;
9780 sort_by_digest = sort_by_digest_4_4;
9781 opti_type = OPTI_TYPE_ZERO_BYTE
9782 | OPTI_TYPE_NOT_ITERATED;
9783 dgst_pos0 = 0;
9784 dgst_pos1 = 1;
9785 dgst_pos2 = 2;
9786 dgst_pos3 = 3;
9787 break;
9788
9789 case 10410: hash_type = HASH_TYPE_PDFU16;
9790 salt_type = SALT_TYPE_EMBEDDED;
9791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9792 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9793 kern_type = KERN_TYPE_PDF11CM1;
9794 dgst_size = DGST_SIZE_4_4;
9795 parse_func = pdf11cm1_parse_hash;
9796 sort_by_digest = sort_by_digest_4_4;
9797 opti_type = OPTI_TYPE_ZERO_BYTE
9798 | OPTI_TYPE_NOT_ITERATED;
9799 dgst_pos0 = 0;
9800 dgst_pos1 = 1;
9801 dgst_pos2 = 2;
9802 dgst_pos3 = 3;
9803 break;
9804
9805 case 10420: hash_type = HASH_TYPE_PDFU16;
9806 salt_type = SALT_TYPE_EMBEDDED;
9807 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9808 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9809 kern_type = KERN_TYPE_PDF11CM2;
9810 dgst_size = DGST_SIZE_4_4;
9811 parse_func = pdf11cm2_parse_hash;
9812 sort_by_digest = sort_by_digest_4_4;
9813 opti_type = OPTI_TYPE_ZERO_BYTE
9814 | OPTI_TYPE_NOT_ITERATED;
9815 dgst_pos0 = 0;
9816 dgst_pos1 = 1;
9817 dgst_pos2 = 2;
9818 dgst_pos3 = 3;
9819 break;
9820
9821 case 10500: hash_type = HASH_TYPE_PDFU16;
9822 salt_type = SALT_TYPE_EMBEDDED;
9823 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9824 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9825 kern_type = KERN_TYPE_PDF14;
9826 dgst_size = DGST_SIZE_4_4;
9827 parse_func = pdf14_parse_hash;
9828 sort_by_digest = sort_by_digest_4_4;
9829 opti_type = OPTI_TYPE_ZERO_BYTE
9830 | OPTI_TYPE_NOT_ITERATED;
9831 dgst_pos0 = 0;
9832 dgst_pos1 = 1;
9833 dgst_pos2 = 2;
9834 dgst_pos3 = 3;
9835 break;
9836
9837 case 10600: hash_type = HASH_TYPE_SHA256;
9838 salt_type = SALT_TYPE_EMBEDDED;
9839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9840 opts_type = OPTS_TYPE_PT_GENERATE_BE
9841 | OPTS_TYPE_ST_ADD80
9842 | OPTS_TYPE_ST_ADDBITS15
9843 | OPTS_TYPE_HASH_COPY;
9844 kern_type = KERN_TYPE_SHA256_PWSLT;
9845 dgst_size = DGST_SIZE_4_8;
9846 parse_func = pdf17l3_parse_hash;
9847 sort_by_digest = sort_by_digest_4_8;
9848 opti_type = OPTI_TYPE_ZERO_BYTE
9849 | OPTI_TYPE_PRECOMPUTE_INIT
9850 | OPTI_TYPE_PRECOMPUTE_MERKLE
9851 | OPTI_TYPE_EARLY_SKIP
9852 | OPTI_TYPE_NOT_ITERATED
9853 | OPTI_TYPE_APPENDED_SALT
9854 | OPTI_TYPE_RAW_HASH;
9855 dgst_pos0 = 3;
9856 dgst_pos1 = 7;
9857 dgst_pos2 = 2;
9858 dgst_pos3 = 6;
9859 break;
9860
9861 case 10700: hash_type = HASH_TYPE_PDFU32;
9862 salt_type = SALT_TYPE_EMBEDDED;
9863 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9864 opts_type = OPTS_TYPE_PT_GENERATE_LE
9865 | OPTS_TYPE_HASH_COPY;
9866 kern_type = KERN_TYPE_PDF17L8;
9867 dgst_size = DGST_SIZE_4_8;
9868 parse_func = pdf17l8_parse_hash;
9869 sort_by_digest = sort_by_digest_4_8;
9870 opti_type = OPTI_TYPE_ZERO_BYTE
9871 | OPTI_TYPE_NOT_ITERATED;
9872 dgst_pos0 = 0;
9873 dgst_pos1 = 1;
9874 dgst_pos2 = 2;
9875 dgst_pos3 = 3;
9876 break;
9877
9878 case 10800: hash_type = HASH_TYPE_SHA384;
9879 salt_type = SALT_TYPE_NONE;
9880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9881 opts_type = OPTS_TYPE_PT_GENERATE_BE
9882 | OPTS_TYPE_PT_ADD80
9883 | OPTS_TYPE_PT_ADDBITS15;
9884 kern_type = KERN_TYPE_SHA384;
9885 dgst_size = DGST_SIZE_8_8;
9886 parse_func = sha384_parse_hash;
9887 sort_by_digest = sort_by_digest_8_8;
9888 opti_type = OPTI_TYPE_ZERO_BYTE
9889 | OPTI_TYPE_PRECOMPUTE_INIT
9890 | OPTI_TYPE_PRECOMPUTE_MERKLE
9891 | OPTI_TYPE_EARLY_SKIP
9892 | OPTI_TYPE_NOT_ITERATED
9893 | OPTI_TYPE_NOT_SALTED
9894 | OPTI_TYPE_USES_BITS_64
9895 | OPTI_TYPE_RAW_HASH;
9896 dgst_pos0 = 6;
9897 dgst_pos1 = 7;
9898 dgst_pos2 = 4;
9899 dgst_pos3 = 5;
9900 break;
9901
9902 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9903 salt_type = SALT_TYPE_EMBEDDED;
9904 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9905 opts_type = OPTS_TYPE_PT_GENERATE_LE
9906 | OPTS_TYPE_ST_BASE64
9907 | OPTS_TYPE_HASH_COPY;
9908 kern_type = KERN_TYPE_PBKDF2_SHA256;
9909 dgst_size = DGST_SIZE_4_32;
9910 parse_func = pbkdf2_sha256_parse_hash;
9911 sort_by_digest = sort_by_digest_4_32;
9912 opti_type = OPTI_TYPE_ZERO_BYTE;
9913 dgst_pos0 = 0;
9914 dgst_pos1 = 1;
9915 dgst_pos2 = 2;
9916 dgst_pos3 = 3;
9917 break;
9918
9919 case 11000: hash_type = HASH_TYPE_MD5;
9920 salt_type = SALT_TYPE_INTERN;
9921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9922 opts_type = OPTS_TYPE_PT_GENERATE_LE
9923 | OPTS_TYPE_PT_ADD80;
9924 kern_type = KERN_TYPE_PRESTASHOP;
9925 dgst_size = DGST_SIZE_4_4;
9926 parse_func = prestashop_parse_hash;
9927 sort_by_digest = sort_by_digest_4_4;
9928 opti_type = OPTI_TYPE_ZERO_BYTE
9929 | OPTI_TYPE_PRECOMPUTE_INIT
9930 | OPTI_TYPE_NOT_ITERATED
9931 | OPTI_TYPE_PREPENDED_SALT;
9932 dgst_pos0 = 0;
9933 dgst_pos1 = 3;
9934 dgst_pos2 = 2;
9935 dgst_pos3 = 1;
9936 break;
9937
9938 case 11100: hash_type = HASH_TYPE_MD5;
9939 salt_type = SALT_TYPE_EMBEDDED;
9940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9941 opts_type = OPTS_TYPE_PT_GENERATE_LE
9942 | OPTS_TYPE_ST_ADD80;
9943 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9944 dgst_size = DGST_SIZE_4_4;
9945 parse_func = postgresql_auth_parse_hash;
9946 sort_by_digest = sort_by_digest_4_4;
9947 opti_type = OPTI_TYPE_ZERO_BYTE
9948 | OPTI_TYPE_PRECOMPUTE_INIT
9949 | OPTI_TYPE_PRECOMPUTE_MERKLE
9950 | OPTI_TYPE_EARLY_SKIP;
9951 dgst_pos0 = 0;
9952 dgst_pos1 = 3;
9953 dgst_pos2 = 2;
9954 dgst_pos3 = 1;
9955 break;
9956
9957 case 11200: hash_type = HASH_TYPE_SHA1;
9958 salt_type = SALT_TYPE_EMBEDDED;
9959 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9960 opts_type = OPTS_TYPE_PT_GENERATE_BE
9961 | OPTS_TYPE_PT_ADD80
9962 | OPTS_TYPE_ST_HEX;
9963 kern_type = KERN_TYPE_MYSQL_AUTH;
9964 dgst_size = DGST_SIZE_4_5;
9965 parse_func = mysql_auth_parse_hash;
9966 sort_by_digest = sort_by_digest_4_5;
9967 opti_type = OPTI_TYPE_ZERO_BYTE
9968 | OPTI_TYPE_EARLY_SKIP;
9969 dgst_pos0 = 3;
9970 dgst_pos1 = 4;
9971 dgst_pos2 = 2;
9972 dgst_pos3 = 1;
9973 break;
9974
9975 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9976 salt_type = SALT_TYPE_EMBEDDED;
9977 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9978 opts_type = OPTS_TYPE_PT_GENERATE_LE
9979 | OPTS_TYPE_ST_HEX
9980 | OPTS_TYPE_ST_ADD80;
9981 kern_type = KERN_TYPE_BITCOIN_WALLET;
9982 dgst_size = DGST_SIZE_4_4;
9983 parse_func = bitcoin_wallet_parse_hash;
9984 sort_by_digest = sort_by_digest_4_4;
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 11400: hash_type = HASH_TYPE_MD5;
9993 salt_type = SALT_TYPE_EMBEDDED;
9994 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9995 opts_type = OPTS_TYPE_PT_GENERATE_LE
9996 | OPTS_TYPE_PT_ADD80
9997 | OPTS_TYPE_HASH_COPY;
9998 kern_type = KERN_TYPE_SIP_AUTH;
9999 dgst_size = DGST_SIZE_4_4;
10000 parse_func = sip_auth_parse_hash;
10001 sort_by_digest = sort_by_digest_4_4;
10002 opti_type = OPTI_TYPE_ZERO_BYTE;
10003 dgst_pos0 = 0;
10004 dgst_pos1 = 3;
10005 dgst_pos2 = 2;
10006 dgst_pos3 = 1;
10007 break;
10008
10009 case 11500: hash_type = HASH_TYPE_CRC32;
10010 salt_type = SALT_TYPE_INTERN;
10011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10012 opts_type = OPTS_TYPE_PT_GENERATE_LE
10013 | OPTS_TYPE_ST_GENERATE_LE
10014 | OPTS_TYPE_ST_HEX;
10015 kern_type = KERN_TYPE_CRC32;
10016 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10017 parse_func = crc32_parse_hash;
10018 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10019 opti_type = OPTI_TYPE_ZERO_BYTE;
10020 dgst_pos0 = 0;
10021 dgst_pos1 = 1;
10022 dgst_pos2 = 2;
10023 dgst_pos3 = 3;
10024 break;
10025
10026 case 11600: hash_type = HASH_TYPE_AES;
10027 salt_type = SALT_TYPE_EMBEDDED;
10028 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10029 opts_type = OPTS_TYPE_PT_GENERATE_LE
10030 | OPTS_TYPE_PT_NEVERCRACK;
10031 kern_type = KERN_TYPE_SEVEN_ZIP;
10032 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10033 parse_func = seven_zip_parse_hash;
10034 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10035 opti_type = OPTI_TYPE_ZERO_BYTE;
10036 dgst_pos0 = 0;
10037 dgst_pos1 = 1;
10038 dgst_pos2 = 2;
10039 dgst_pos3 = 3;
10040 break;
10041
10042 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10043 salt_type = SALT_TYPE_NONE;
10044 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10045 opts_type = OPTS_TYPE_PT_GENERATE_LE
10046 | OPTS_TYPE_PT_ADD01;
10047 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10048 dgst_size = DGST_SIZE_4_8;
10049 parse_func = gost2012sbog_256_parse_hash;
10050 sort_by_digest = sort_by_digest_4_8;
10051 opti_type = OPTI_TYPE_ZERO_BYTE;
10052 dgst_pos0 = 0;
10053 dgst_pos1 = 1;
10054 dgst_pos2 = 2;
10055 dgst_pos3 = 3;
10056 break;
10057
10058 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10059 salt_type = SALT_TYPE_NONE;
10060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10061 opts_type = OPTS_TYPE_PT_GENERATE_LE
10062 | OPTS_TYPE_PT_ADD01;
10063 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10064 dgst_size = DGST_SIZE_4_16;
10065 parse_func = gost2012sbog_512_parse_hash;
10066 sort_by_digest = sort_by_digest_4_16;
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 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
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_MD5;
10081 dgst_size = DGST_SIZE_4_32;
10082 parse_func = pbkdf2_md5_parse_hash;
10083 sort_by_digest = sort_by_digest_4_32;
10084 opti_type = OPTI_TYPE_ZERO_BYTE;
10085 dgst_pos0 = 0;
10086 dgst_pos1 = 1;
10087 dgst_pos2 = 2;
10088 dgst_pos3 = 3;
10089 break;
10090
10091 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10092 salt_type = SALT_TYPE_EMBEDDED;
10093 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10094 opts_type = OPTS_TYPE_PT_GENERATE_LE
10095 | OPTS_TYPE_ST_BASE64
10096 | OPTS_TYPE_HASH_COPY;
10097 kern_type = KERN_TYPE_PBKDF2_SHA1;
10098 dgst_size = DGST_SIZE_4_32;
10099 parse_func = pbkdf2_sha1_parse_hash;
10100 sort_by_digest = sort_by_digest_4_32;
10101 opti_type = OPTI_TYPE_ZERO_BYTE;
10102 dgst_pos0 = 0;
10103 dgst_pos1 = 1;
10104 dgst_pos2 = 2;
10105 dgst_pos3 = 3;
10106 break;
10107
10108 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10109 salt_type = SALT_TYPE_EMBEDDED;
10110 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10111 opts_type = OPTS_TYPE_PT_GENERATE_LE
10112 | OPTS_TYPE_ST_BASE64
10113 | OPTS_TYPE_HASH_COPY;
10114 kern_type = KERN_TYPE_PBKDF2_SHA512;
10115 dgst_size = DGST_SIZE_8_16;
10116 parse_func = pbkdf2_sha512_parse_hash;
10117 sort_by_digest = sort_by_digest_8_16;
10118 opti_type = OPTI_TYPE_ZERO_BYTE
10119 | OPTI_TYPE_USES_BITS_64;
10120 dgst_pos0 = 0;
10121 dgst_pos1 = 1;
10122 dgst_pos2 = 2;
10123 dgst_pos3 = 3;
10124 break;
10125
10126 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10127 salt_type = SALT_TYPE_EMBEDDED;
10128 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10129 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10130 kern_type = KERN_TYPE_ECRYPTFS;
10131 dgst_size = DGST_SIZE_8_8;
10132 parse_func = ecryptfs_parse_hash;
10133 sort_by_digest = sort_by_digest_8_8;
10134 opti_type = OPTI_TYPE_ZERO_BYTE
10135 | OPTI_TYPE_USES_BITS_64;
10136 dgst_pos0 = 0;
10137 dgst_pos1 = 1;
10138 dgst_pos2 = 2;
10139 dgst_pos3 = 3;
10140 break;
10141
10142 case 12300: hash_type = HASH_TYPE_ORACLET;
10143 salt_type = SALT_TYPE_EMBEDDED;
10144 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10145 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10146 kern_type = KERN_TYPE_ORACLET;
10147 dgst_size = DGST_SIZE_8_16;
10148 parse_func = oraclet_parse_hash;
10149 sort_by_digest = sort_by_digest_8_16;
10150 opti_type = OPTI_TYPE_ZERO_BYTE
10151 | OPTI_TYPE_USES_BITS_64;
10152 dgst_pos0 = 0;
10153 dgst_pos1 = 1;
10154 dgst_pos2 = 2;
10155 dgst_pos3 = 3;
10156 break;
10157
10158 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10159 salt_type = SALT_TYPE_EMBEDDED;
10160 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10161 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10162 kern_type = KERN_TYPE_BSDICRYPT;
10163 dgst_size = DGST_SIZE_4_4;
10164 parse_func = bsdicrypt_parse_hash;
10165 sort_by_digest = sort_by_digest_4_4;
10166 opti_type = OPTI_TYPE_ZERO_BYTE
10167 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10168 dgst_pos0 = 0;
10169 dgst_pos1 = 1;
10170 dgst_pos2 = 2;
10171 dgst_pos3 = 3;
10172 break;
10173
10174 case 12500: hash_type = HASH_TYPE_RAR3HP;
10175 salt_type = SALT_TYPE_EMBEDDED;
10176 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10177 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10178 kern_type = KERN_TYPE_RAR3;
10179 dgst_size = DGST_SIZE_4_4;
10180 parse_func = rar3hp_parse_hash;
10181 sort_by_digest = sort_by_digest_4_4;
10182 opti_type = OPTI_TYPE_ZERO_BYTE;
10183 dgst_pos0 = 0;
10184 dgst_pos1 = 1;
10185 dgst_pos2 = 2;
10186 dgst_pos3 = 3;
10187 break;
10188
10189 case 12600: hash_type = HASH_TYPE_SHA256;
10190 salt_type = SALT_TYPE_INTERN;
10191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10192 opts_type = OPTS_TYPE_PT_GENERATE_BE
10193 | OPTS_TYPE_PT_ADD80;
10194 kern_type = KERN_TYPE_CF10;
10195 dgst_size = DGST_SIZE_4_8;
10196 parse_func = cf10_parse_hash;
10197 sort_by_digest = sort_by_digest_4_8;
10198 opti_type = OPTI_TYPE_ZERO_BYTE
10199 | OPTI_TYPE_PRECOMPUTE_INIT
10200 | OPTI_TYPE_EARLY_SKIP
10201 | OPTI_TYPE_NOT_ITERATED;
10202 dgst_pos0 = 3;
10203 dgst_pos1 = 7;
10204 dgst_pos2 = 2;
10205 dgst_pos3 = 6;
10206 break;
10207
10208 case 12700: hash_type = HASH_TYPE_AES;
10209 salt_type = SALT_TYPE_EMBEDDED;
10210 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10211 opts_type = OPTS_TYPE_PT_GENERATE_LE
10212 | OPTS_TYPE_HASH_COPY;
10213 kern_type = KERN_TYPE_MYWALLET;
10214 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10215 parse_func = mywallet_parse_hash;
10216 sort_by_digest = sort_by_digest_4_5;
10217 opti_type = OPTI_TYPE_ZERO_BYTE;
10218 dgst_pos0 = 0;
10219 dgst_pos1 = 1;
10220 dgst_pos2 = 2;
10221 dgst_pos3 = 3;
10222 break;
10223
10224 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10225 salt_type = SALT_TYPE_EMBEDDED;
10226 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10227 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10228 kern_type = KERN_TYPE_MS_DRSR;
10229 dgst_size = DGST_SIZE_4_8;
10230 parse_func = ms_drsr_parse_hash;
10231 sort_by_digest = sort_by_digest_4_8;
10232 opti_type = OPTI_TYPE_ZERO_BYTE;
10233 dgst_pos0 = 0;
10234 dgst_pos1 = 1;
10235 dgst_pos2 = 2;
10236 dgst_pos3 = 3;
10237 break;
10238
10239 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10240 salt_type = SALT_TYPE_EMBEDDED;
10241 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10242 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10243 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10244 dgst_size = DGST_SIZE_4_8;
10245 parse_func = androidfde_samsung_parse_hash;
10246 sort_by_digest = sort_by_digest_4_8;
10247 opti_type = OPTI_TYPE_ZERO_BYTE;
10248 dgst_pos0 = 0;
10249 dgst_pos1 = 1;
10250 dgst_pos2 = 2;
10251 dgst_pos3 = 3;
10252 break;
10253
10254 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10255 salt_type = SALT_TYPE_EMBEDDED;
10256 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10257 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10258 kern_type = KERN_TYPE_RAR5;
10259 dgst_size = DGST_SIZE_4_4;
10260 parse_func = rar5_parse_hash;
10261 sort_by_digest = sort_by_digest_4_4;
10262 opti_type = OPTI_TYPE_ZERO_BYTE;
10263 dgst_pos0 = 0;
10264 dgst_pos1 = 1;
10265 dgst_pos2 = 2;
10266 dgst_pos3 = 3;
10267 break;
10268
10269 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10270 salt_type = SALT_TYPE_EMBEDDED;
10271 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10272 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10273 kern_type = KERN_TYPE_KRB5TGS;
10274 dgst_size = DGST_SIZE_4_4;
10275 parse_func = krb5tgs_parse_hash;
10276 sort_by_digest = sort_by_digest_4_4;
10277 opti_type = OPTI_TYPE_ZERO_BYTE
10278 | OPTI_TYPE_NOT_ITERATED;
10279 dgst_pos0 = 0;
10280 dgst_pos1 = 1;
10281 dgst_pos2 = 2;
10282 dgst_pos3 = 3;
10283 break;
10284
10285 case 13200: hash_type = HASH_TYPE_AES;
10286 salt_type = SALT_TYPE_EMBEDDED;
10287 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10288 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10289 kern_type = KERN_TYPE_AXCRYPT;
10290 dgst_size = DGST_SIZE_4_4;
10291 parse_func = axcrypt_parse_hash;
10292 sort_by_digest = sort_by_digest_4_4;
10293 opti_type = OPTI_TYPE_ZERO_BYTE;
10294 dgst_pos0 = 0;
10295 dgst_pos1 = 1;
10296 dgst_pos2 = 2;
10297 dgst_pos3 = 3;
10298 break;
10299
10300 case 13300: hash_type = HASH_TYPE_SHA1;
10301 salt_type = SALT_TYPE_NONE;
10302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10303 opts_type = OPTS_TYPE_PT_GENERATE_BE
10304 | OPTS_TYPE_PT_ADD80
10305 | OPTS_TYPE_PT_ADDBITS15;
10306 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10307 dgst_size = DGST_SIZE_4_5;
10308 parse_func = sha1axcrypt_parse_hash;
10309 sort_by_digest = sort_by_digest_4_5;
10310 opti_type = OPTI_TYPE_ZERO_BYTE
10311 | OPTI_TYPE_PRECOMPUTE_INIT
10312 | OPTI_TYPE_EARLY_SKIP
10313 | OPTI_TYPE_NOT_ITERATED
10314 | OPTI_TYPE_NOT_SALTED;
10315 dgst_pos0 = 0;
10316 dgst_pos1 = 4;
10317 dgst_pos2 = 3;
10318 dgst_pos3 = 2;
10319 break;
10320
10321 case 13400: hash_type = HASH_TYPE_AES;
10322 salt_type = SALT_TYPE_EMBEDDED;
10323 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10324 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10325 kern_type = KERN_TYPE_KEEPASS;
10326 dgst_size = DGST_SIZE_4_4;
10327 parse_func = keepass_parse_hash;
10328 sort_by_digest = sort_by_digest_4_4;
10329 opti_type = OPTI_TYPE_ZERO_BYTE;
10330 dgst_pos0 = 0;
10331 dgst_pos1 = 1;
10332 dgst_pos2 = 2;
10333 dgst_pos3 = 3;
10334 break;
10335
10336 case 13500: hash_type = HASH_TYPE_SHA1;
10337 salt_type = SALT_TYPE_EMBEDDED;
10338 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10339 opts_type = OPTS_TYPE_PT_GENERATE_BE
10340 | OPTS_TYPE_PT_UNICODE
10341 | OPTS_TYPE_PT_ADD80;
10342 kern_type = KERN_TYPE_PSTOKEN;
10343 dgst_size = DGST_SIZE_4_5;
10344 parse_func = pstoken_parse_hash;
10345 sort_by_digest = sort_by_digest_4_5;
10346 opti_type = OPTI_TYPE_ZERO_BYTE
10347 | OPTI_TYPE_PRECOMPUTE_INIT
10348 | OPTI_TYPE_EARLY_SKIP
10349 | OPTI_TYPE_NOT_ITERATED
10350 | OPTI_TYPE_PREPENDED_SALT
10351 | OPTI_TYPE_RAW_HASH;
10352 dgst_pos0 = 3;
10353 dgst_pos1 = 4;
10354 dgst_pos2 = 2;
10355 dgst_pos3 = 1;
10356 break;
10357
10358 default: usage_mini_print (PROGNAME); return (-1);
10359 }
10360
10361 /**
10362 * parser
10363 */
10364
10365 data.parse_func = parse_func;
10366
10367 /**
10368 * misc stuff
10369 */
10370
10371 if (hex_salt)
10372 {
10373 if (salt_type == SALT_TYPE_INTERN)
10374 {
10375 opts_type |= OPTS_TYPE_ST_HEX;
10376 }
10377 else
10378 {
10379 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10380
10381 return (-1);
10382 }
10383 }
10384
10385 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10386 | (salt_type == SALT_TYPE_EXTERN)
10387 | (salt_type == SALT_TYPE_EMBEDDED)
10388 | (salt_type == SALT_TYPE_VIRTUAL));
10389
10390 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10391
10392 data.hash_type = hash_type;
10393 data.attack_mode = attack_mode;
10394 data.attack_kern = attack_kern;
10395 data.attack_exec = attack_exec;
10396 data.kern_type = kern_type;
10397 data.opts_type = opts_type;
10398 data.dgst_size = dgst_size;
10399 data.salt_type = salt_type;
10400 data.isSalted = isSalted;
10401 data.sort_by_digest = sort_by_digest;
10402 data.dgst_pos0 = dgst_pos0;
10403 data.dgst_pos1 = dgst_pos1;
10404 data.dgst_pos2 = dgst_pos2;
10405 data.dgst_pos3 = dgst_pos3;
10406
10407 esalt_size = 0;
10408
10409 switch (hash_mode)
10410 {
10411 case 2500: esalt_size = sizeof (wpa_t); break;
10412 case 5300: esalt_size = sizeof (ikepsk_t); break;
10413 case 5400: esalt_size = sizeof (ikepsk_t); break;
10414 case 5500: esalt_size = sizeof (netntlm_t); break;
10415 case 5600: esalt_size = sizeof (netntlm_t); break;
10416 case 6211: esalt_size = sizeof (tc_t); break;
10417 case 6212: esalt_size = sizeof (tc_t); break;
10418 case 6213: esalt_size = sizeof (tc_t); break;
10419 case 6221: esalt_size = sizeof (tc_t); break;
10420 case 6222: esalt_size = sizeof (tc_t); break;
10421 case 6223: esalt_size = sizeof (tc_t); break;
10422 case 6231: esalt_size = sizeof (tc_t); break;
10423 case 6232: esalt_size = sizeof (tc_t); break;
10424 case 6233: esalt_size = sizeof (tc_t); break;
10425 case 6241: esalt_size = sizeof (tc_t); break;
10426 case 6242: esalt_size = sizeof (tc_t); break;
10427 case 6243: esalt_size = sizeof (tc_t); break;
10428 case 6600: esalt_size = sizeof (agilekey_t); break;
10429 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10430 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10431 case 7300: esalt_size = sizeof (rakp_t); break;
10432 case 7500: esalt_size = sizeof (krb5pa_t); break;
10433 case 8200: esalt_size = sizeof (cloudkey_t); break;
10434 case 8800: esalt_size = sizeof (androidfde_t); break;
10435 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10436 case 9400: esalt_size = sizeof (office2007_t); break;
10437 case 9500: esalt_size = sizeof (office2010_t); break;
10438 case 9600: esalt_size = sizeof (office2013_t); break;
10439 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10440 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10441 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10442 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10443 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10444 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10445 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10446 case 10200: esalt_size = sizeof (cram_md5_t); break;
10447 case 10400: esalt_size = sizeof (pdf_t); break;
10448 case 10410: esalt_size = sizeof (pdf_t); break;
10449 case 10420: esalt_size = sizeof (pdf_t); break;
10450 case 10500: esalt_size = sizeof (pdf_t); break;
10451 case 10600: esalt_size = sizeof (pdf_t); break;
10452 case 10700: esalt_size = sizeof (pdf_t); break;
10453 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10454 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10455 case 11400: esalt_size = sizeof (sip_t); break;
10456 case 11600: esalt_size = sizeof (seven_zip_t); break;
10457 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10458 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10459 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10460 case 13000: esalt_size = sizeof (rar5_t); break;
10461 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10462 case 13400: esalt_size = sizeof (keepass_t); break;
10463 case 13500: esalt_size = sizeof (pstoken_t); break;
10464 }
10465
10466 data.esalt_size = esalt_size;
10467
10468 /**
10469 * choose dictionary parser
10470 */
10471
10472 if (hash_type == HASH_TYPE_LM)
10473 {
10474 get_next_word_func = get_next_word_lm;
10475 }
10476 else if (opts_type & OPTS_TYPE_PT_UPPER)
10477 {
10478 get_next_word_func = get_next_word_uc;
10479 }
10480 else
10481 {
10482 get_next_word_func = get_next_word_std;
10483 }
10484
10485 /**
10486 * dictstat
10487 */
10488
10489 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10490
10491 #ifdef _POSIX
10492 size_t dictstat_nmemb = 0;
10493 #endif
10494
10495 #ifdef _WIN
10496 uint dictstat_nmemb = 0;
10497 #endif
10498
10499 char dictstat[256] = { 0 };
10500
10501 FILE *dictstat_fp = NULL;
10502
10503 if (keyspace == 0)
10504 {
10505 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10506
10507 dictstat_fp = fopen (dictstat, "rb");
10508
10509 if (dictstat_fp)
10510 {
10511 #ifdef _POSIX
10512 struct stat tmpstat;
10513
10514 fstat (fileno (dictstat_fp), &tmpstat);
10515 #endif
10516
10517 #ifdef _WIN
10518 struct stat64 tmpstat;
10519
10520 _fstat64 (fileno (dictstat_fp), &tmpstat);
10521 #endif
10522
10523 if (tmpstat.st_mtime < COMPTIME)
10524 {
10525 /* with v0.15 the format changed so we have to ensure user is using a good version
10526 since there is no version-header in the dictstat file */
10527
10528 fclose (dictstat_fp);
10529
10530 unlink (dictstat);
10531 }
10532 else
10533 {
10534 while (!feof (dictstat_fp))
10535 {
10536 dictstat_t d;
10537
10538 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10539
10540 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10541
10542 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10543 {
10544 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10545
10546 return -1;
10547 }
10548 }
10549
10550 fclose (dictstat_fp);
10551 }
10552 }
10553 }
10554
10555 /**
10556 * potfile
10557 */
10558
10559 char potfile[256] = { 0 };
10560
10561 if (potfile_path == NULL)
10562 {
10563 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10564 }
10565 else
10566 {
10567 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10568 }
10569
10570 data.pot_fp = NULL;
10571
10572 FILE *out_fp = NULL;
10573 FILE *pot_fp = NULL;
10574
10575 if (show == 1 || left == 1)
10576 {
10577 pot_fp = fopen (potfile, "rb");
10578
10579 if (pot_fp == NULL)
10580 {
10581 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10582
10583 return (-1);
10584 }
10585
10586 if (outfile != NULL)
10587 {
10588 if ((out_fp = fopen (outfile, "ab")) == NULL)
10589 {
10590 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10591
10592 fclose (pot_fp);
10593
10594 return (-1);
10595 }
10596 }
10597 else
10598 {
10599 out_fp = stdout;
10600 }
10601 }
10602 else
10603 {
10604 if (potfile_disable == 0)
10605 {
10606 pot_fp = fopen (potfile, "ab");
10607
10608 if (pot_fp == NULL)
10609 {
10610 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10611
10612 return (-1);
10613 }
10614
10615 data.pot_fp = pot_fp;
10616 }
10617 }
10618
10619 pot_t *pot = NULL;
10620
10621 uint pot_cnt = 0;
10622 uint pot_avail = 0;
10623
10624 if (show == 1 || left == 1)
10625 {
10626 SUPPRESS_OUTPUT = 1;
10627
10628 pot_avail = count_lines (pot_fp);
10629
10630 rewind (pot_fp);
10631
10632 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10633
10634 uint pot_hashes_avail = 0;
10635
10636 uint line_num = 0;
10637
10638 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10639
10640 while (!feof (pot_fp))
10641 {
10642 line_num++;
10643
10644 int line_len = fgetl (pot_fp, line_buf);
10645
10646 if (line_len == 0) continue;
10647
10648 char *plain_buf = line_buf + line_len;
10649
10650 pot_t *pot_ptr = &pot[pot_cnt];
10651
10652 hash_t *hashes_buf = &pot_ptr->hash;
10653
10654 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10655 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10656
10657 if (pot_cnt == pot_hashes_avail)
10658 {
10659 uint pos = 0;
10660
10661 for (pos = 0; pos < INCR_POT; pos++)
10662 {
10663 if ((pot_cnt + pos) >= pot_avail) break;
10664
10665 pot_t *tmp_pot = &pot[pot_cnt + pos];
10666
10667 hash_t *tmp_hash = &tmp_pot->hash;
10668
10669 tmp_hash->digest = mymalloc (dgst_size);
10670
10671 if (isSalted)
10672 {
10673 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10674 }
10675
10676 if (esalt_size)
10677 {
10678 tmp_hash->esalt = mymalloc (esalt_size);
10679 }
10680
10681 pot_hashes_avail++;
10682 }
10683 }
10684
10685 int plain_len = 0;
10686
10687 int parser_status;
10688
10689 int iter = MAX_CUT_TRIES;
10690
10691 do
10692 {
10693 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10694 {
10695 if (line_buf[i] == ':')
10696 {
10697 line_len--;
10698
10699 break;
10700 }
10701 }
10702
10703 if (data.hash_mode != 2500)
10704 {
10705 parser_status = parse_func (line_buf, line_len, hashes_buf);
10706 }
10707 else
10708 {
10709 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10710
10711 if (line_len > max_salt_size)
10712 {
10713 parser_status = PARSER_GLOBAL_LENGTH;
10714 }
10715 else
10716 {
10717 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10718
10719 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10720
10721 hashes_buf->salt->salt_len = line_len;
10722
10723 parser_status = PARSER_OK;
10724 }
10725 }
10726
10727 // if NOT parsed without error, we add the ":" to the plain
10728
10729 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10730 {
10731 plain_len++;
10732 plain_buf--;
10733 }
10734
10735 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10736
10737 if (parser_status < PARSER_GLOBAL_ZERO)
10738 {
10739 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10740
10741 continue;
10742 }
10743
10744 if (plain_len >= 255) continue;
10745
10746 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10747
10748 pot_ptr->plain_len = plain_len;
10749
10750 pot_cnt++;
10751 }
10752
10753 myfree (line_buf);
10754
10755 fclose (pot_fp);
10756
10757 SUPPRESS_OUTPUT = 0;
10758
10759 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10760 }
10761
10762 /**
10763 * word len
10764 */
10765
10766 uint pw_min = PW_MIN;
10767 uint pw_max = PW_MAX;
10768
10769 switch (hash_mode)
10770 {
10771 case 125: if (pw_max > 32) pw_max = 32;
10772 break;
10773 case 400: if (pw_max > 40) pw_max = 40;
10774 break;
10775 case 500: if (pw_max > 16) pw_max = 16;
10776 break;
10777 case 1500: if (pw_max > 8) pw_max = 8;
10778 break;
10779 case 1600: if (pw_max > 16) pw_max = 16;
10780 break;
10781 case 1800: if (pw_max > 16) pw_max = 16;
10782 break;
10783 case 2100: if (pw_max > 16) pw_max = 16;
10784 break;
10785 case 2500: if (pw_min < 8) pw_min = 8;
10786 break;
10787 case 3000: if (pw_max > 7) pw_max = 7;
10788 break;
10789 case 5200: if (pw_max > 24) pw_max = 24;
10790 break;
10791 case 5800: if (pw_max > 16) pw_max = 16;
10792 break;
10793 case 6300: if (pw_max > 16) pw_max = 16;
10794 break;
10795 case 7400: if (pw_max > 16) pw_max = 16;
10796 break;
10797 case 7900: if (pw_max > 48) pw_max = 48;
10798 break;
10799 case 8500: if (pw_max > 8) pw_max = 8;
10800 break;
10801 case 8600: if (pw_max > 16) pw_max = 16;
10802 break;
10803 case 9710: pw_min = 5;
10804 pw_max = 5;
10805 break;
10806 case 9810: pw_min = 5;
10807 pw_max = 5;
10808 break;
10809 case 10410: pw_min = 5;
10810 pw_max = 5;
10811 break;
10812 case 10300: if (pw_max < 3) pw_min = 3;
10813 if (pw_max > 40) pw_max = 40;
10814 break;
10815 case 10500: if (pw_max < 3) pw_min = 3;
10816 if (pw_max > 40) pw_max = 40;
10817 break;
10818 case 10700: if (pw_max > 16) pw_max = 16;
10819 break;
10820 case 11300: if (pw_max > 40) pw_max = 40;
10821 break;
10822 case 12500: if (pw_max > 20) pw_max = 20;
10823 break;
10824 case 12800: if (pw_max > 24) pw_max = 24;
10825 break;
10826 }
10827
10828 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10829 {
10830 switch (attack_kern)
10831 {
10832 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10833 break;
10834 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10835 break;
10836 }
10837 }
10838
10839 /**
10840 * charsets : keep them together for more easy maintainnce
10841 */
10842
10843 cs_t mp_sys[6] = { { { 0 }, 0 } };
10844 cs_t mp_usr[4] = { { { 0 }, 0 } };
10845
10846 mp_setup_sys (mp_sys);
10847
10848 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10849 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10850 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10851 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10852
10853 /**
10854 * load hashes, part I: find input mode, count hashes
10855 */
10856
10857 uint hashlist_mode = 0;
10858 uint hashlist_format = HLFMT_HASHCAT;
10859
10860 uint hashes_avail = 0;
10861
10862 if (benchmark == 0)
10863 {
10864 struct stat f;
10865
10866 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10867
10868 if ((hash_mode == 2500) ||
10869 (hash_mode == 5200) ||
10870 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10871 (hash_mode == 9000))
10872 {
10873 hashlist_mode = HL_MODE_ARG;
10874
10875 char *hashfile = myargv[optind];
10876
10877 data.hashfile = hashfile;
10878
10879 logfile_top_var_string ("target", hashfile);
10880 }
10881
10882 if (hashlist_mode == HL_MODE_ARG)
10883 {
10884 if (hash_mode == 2500)
10885 {
10886 struct stat st;
10887
10888 if (stat (data.hashfile, &st) == -1)
10889 {
10890 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10891
10892 return (-1);
10893 }
10894
10895 hashes_avail = st.st_size / sizeof (hccap_t);
10896 }
10897 else
10898 {
10899 hashes_avail = 1;
10900 }
10901 }
10902 else if (hashlist_mode == HL_MODE_FILE)
10903 {
10904 char *hashfile = myargv[optind];
10905
10906 data.hashfile = hashfile;
10907
10908 logfile_top_var_string ("target", hashfile);
10909
10910 FILE *fp = NULL;
10911
10912 if ((fp = fopen (hashfile, "rb")) == NULL)
10913 {
10914 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10915
10916 return (-1);
10917 }
10918
10919 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10920
10921 hashes_avail = count_lines (fp);
10922
10923 rewind (fp);
10924
10925 if (hashes_avail == 0)
10926 {
10927 log_error ("ERROR: hashfile is empty or corrupt");
10928
10929 fclose (fp);
10930
10931 return (-1);
10932 }
10933
10934 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10935
10936 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10937 {
10938 log_error ("ERROR: remove not supported in native hashfile-format mode");
10939
10940 fclose (fp);
10941
10942 return (-1);
10943 }
10944
10945 fclose (fp);
10946 }
10947 }
10948 else
10949 {
10950 hashlist_mode = HL_MODE_ARG;
10951
10952 hashes_avail = 1;
10953 }
10954
10955 if (hash_mode == 3000) hashes_avail *= 2;
10956
10957 data.hashlist_mode = hashlist_mode;
10958 data.hashlist_format = hashlist_format;
10959
10960 logfile_top_uint (hashlist_mode);
10961 logfile_top_uint (hashlist_format);
10962
10963 /**
10964 * load hashes, part II: allocate required memory, set pointers
10965 */
10966
10967 hash_t *hashes_buf = NULL;
10968 void *digests_buf = NULL;
10969 salt_t *salts_buf = NULL;
10970 void *esalts_buf = NULL;
10971
10972 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10973
10974 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10975
10976 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10977 {
10978 u32 hash_pos;
10979
10980 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10981 {
10982 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10983
10984 hashes_buf[hash_pos].hash_info = hash_info;
10985
10986 if (username && (remove || show || left))
10987 {
10988 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10989 }
10990
10991 if (benchmark)
10992 {
10993 hash_info->orighash = (char *) mymalloc (256);
10994 }
10995 }
10996 }
10997
10998 if (isSalted)
10999 {
11000 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11001
11002 if (esalt_size)
11003 {
11004 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11005 }
11006 }
11007 else
11008 {
11009 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11010 }
11011
11012 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11013 {
11014 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11015
11016 if (isSalted)
11017 {
11018 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11019
11020 if (esalt_size)
11021 {
11022 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11023 }
11024 }
11025 else
11026 {
11027 hashes_buf[hash_pos].salt = &salts_buf[0];
11028 }
11029 }
11030
11031 /**
11032 * load hashes, part III: parse hashes or generate them if benchmark
11033 */
11034
11035 uint hashes_cnt = 0;
11036
11037 if (benchmark == 0)
11038 {
11039 if (keyspace == 1)
11040 {
11041 // useless to read hash file for keyspace, cheat a little bit w/ optind
11042 }
11043 else if (hashes_avail == 0)
11044 {
11045 }
11046 else if (hashlist_mode == HL_MODE_ARG)
11047 {
11048 char *input_buf = myargv[optind];
11049
11050 uint input_len = strlen (input_buf);
11051
11052 logfile_top_var_string ("target", input_buf);
11053
11054 char *hash_buf = NULL;
11055 int hash_len = 0;
11056
11057 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11058
11059 bool hash_fmt_error = 0;
11060
11061 if (hash_len < 1) hash_fmt_error = 1;
11062 if (hash_buf == NULL) hash_fmt_error = 1;
11063
11064 if (hash_fmt_error)
11065 {
11066 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11067 }
11068 else
11069 {
11070 if (opts_type & OPTS_TYPE_HASH_COPY)
11071 {
11072 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11073
11074 hash_info_tmp->orighash = mystrdup (hash_buf);
11075 }
11076
11077 if (isSalted)
11078 {
11079 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11080 }
11081
11082 int parser_status = PARSER_OK;
11083
11084 if (hash_mode == 2500)
11085 {
11086 if (hash_len == 0)
11087 {
11088 log_error ("ERROR: hccap file not specified");
11089
11090 return (-1);
11091 }
11092
11093 hashlist_mode = HL_MODE_FILE;
11094
11095 data.hashlist_mode = hashlist_mode;
11096
11097 FILE *fp = fopen (hash_buf, "rb");
11098
11099 if (fp == NULL)
11100 {
11101 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11102
11103 return (-1);
11104 }
11105
11106 if (hashes_avail < 1)
11107 {
11108 log_error ("ERROR: hccap file is empty or corrupt");
11109
11110 fclose (fp);
11111
11112 return (-1);
11113 }
11114
11115 uint hccap_size = sizeof (hccap_t);
11116
11117 char *in = (char *) mymalloc (hccap_size);
11118
11119 while (!feof (fp))
11120 {
11121 int n = fread (in, hccap_size, 1, fp);
11122
11123 if (n != 1)
11124 {
11125 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11126
11127 break;
11128 }
11129
11130 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11131
11132 if (parser_status != PARSER_OK)
11133 {
11134 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11135
11136 continue;
11137 }
11138
11139 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11140
11141 if ((show == 1) || (left == 1))
11142 {
11143 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11144
11145 char *salt_ptr = (char *) tmp_salt->salt_buf;
11146
11147 int cur_pos = tmp_salt->salt_len;
11148 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11149
11150 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11151
11152 // do the appending task
11153
11154 snprintf (salt_ptr + cur_pos,
11155 rem_len,
11156 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11157 wpa->orig_mac1[0],
11158 wpa->orig_mac1[1],
11159 wpa->orig_mac1[2],
11160 wpa->orig_mac1[3],
11161 wpa->orig_mac1[4],
11162 wpa->orig_mac1[5],
11163 wpa->orig_mac2[0],
11164 wpa->orig_mac2[1],
11165 wpa->orig_mac2[2],
11166 wpa->orig_mac2[3],
11167 wpa->orig_mac2[4],
11168 wpa->orig_mac2[5]);
11169
11170 // memset () the remaining part of the salt
11171
11172 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11173 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11174
11175 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11176
11177 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11178 }
11179
11180 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);
11181 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);
11182
11183 hashes_cnt++;
11184 }
11185
11186 fclose (fp);
11187
11188 myfree (in);
11189 }
11190 else if (hash_mode == 3000)
11191 {
11192 if (hash_len == 32)
11193 {
11194 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11195
11196 hash_t *lm_hash_left = NULL;
11197
11198 if (parser_status == PARSER_OK)
11199 {
11200 lm_hash_left = &hashes_buf[hashes_cnt];
11201
11202 hashes_cnt++;
11203 }
11204 else
11205 {
11206 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11207 }
11208
11209 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11210
11211 hash_t *lm_hash_right = NULL;
11212
11213 if (parser_status == PARSER_OK)
11214 {
11215 lm_hash_right = &hashes_buf[hashes_cnt];
11216
11217 hashes_cnt++;
11218 }
11219 else
11220 {
11221 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11222 }
11223
11224 // show / left
11225
11226 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11227 {
11228 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);
11229 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);
11230 }
11231 }
11232 else
11233 {
11234 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11235
11236 if (parser_status == PARSER_OK)
11237 {
11238 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11239 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11240 }
11241
11242 if (parser_status == PARSER_OK)
11243 {
11244 hashes_cnt++;
11245 }
11246 else
11247 {
11248 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11249 }
11250 }
11251 }
11252 else
11253 {
11254 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11255
11256 if (parser_status == PARSER_OK)
11257 {
11258 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11259 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11260 }
11261
11262 if (parser_status == PARSER_OK)
11263 {
11264 hashes_cnt++;
11265 }
11266 else
11267 {
11268 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11269 }
11270 }
11271 }
11272 }
11273 else if (hashlist_mode == HL_MODE_FILE)
11274 {
11275 char *hashfile = data.hashfile;
11276
11277 FILE *fp;
11278
11279 if ((fp = fopen (hashfile, "rb")) == NULL)
11280 {
11281 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11282
11283 return (-1);
11284 }
11285
11286 uint line_num = 0;
11287
11288 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11289
11290 while (!feof (fp))
11291 {
11292 line_num++;
11293
11294 int line_len = fgetl (fp, line_buf);
11295
11296 if (line_len == 0) continue;
11297
11298 char *hash_buf = NULL;
11299 int hash_len = 0;
11300
11301 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11302
11303 bool hash_fmt_error = 0;
11304
11305 if (hash_len < 1) hash_fmt_error = 1;
11306 if (hash_buf == NULL) hash_fmt_error = 1;
11307
11308 if (hash_fmt_error)
11309 {
11310 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11311
11312 continue;
11313 }
11314
11315 if (username)
11316 {
11317 char *user_buf = NULL;
11318 int user_len = 0;
11319
11320 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11321
11322 if (remove || show)
11323 {
11324 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11325
11326 *user = (user_t *) mymalloc (sizeof (user_t));
11327
11328 user_t *user_ptr = *user;
11329
11330 if (user_buf != NULL)
11331 {
11332 user_ptr->user_name = mystrdup (user_buf);
11333 }
11334 else
11335 {
11336 user_ptr->user_name = mystrdup ("");
11337 }
11338
11339 user_ptr->user_len = user_len;
11340 }
11341 }
11342
11343 if (opts_type & OPTS_TYPE_HASH_COPY)
11344 {
11345 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11346
11347 hash_info_tmp->orighash = mystrdup (hash_buf);
11348 }
11349
11350 if (isSalted)
11351 {
11352 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11353 }
11354
11355 if (hash_mode == 3000)
11356 {
11357 if (hash_len == 32)
11358 {
11359 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11360
11361 if (parser_status < PARSER_GLOBAL_ZERO)
11362 {
11363 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11364
11365 continue;
11366 }
11367
11368 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11369
11370 hashes_cnt++;
11371
11372 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11373
11374 if (parser_status < PARSER_GLOBAL_ZERO)
11375 {
11376 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11377
11378 continue;
11379 }
11380
11381 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11382
11383 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);
11384
11385 hashes_cnt++;
11386
11387 // show / left
11388
11389 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);
11390 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);
11391 }
11392 else
11393 {
11394 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11395
11396 if (parser_status < PARSER_GLOBAL_ZERO)
11397 {
11398 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11399
11400 continue;
11401 }
11402
11403 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);
11404
11405 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11406 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11407
11408 hashes_cnt++;
11409 }
11410 }
11411 else
11412 {
11413 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11414
11415 if (parser_status < PARSER_GLOBAL_ZERO)
11416 {
11417 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11418
11419 continue;
11420 }
11421
11422 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);
11423
11424 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11425 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11426
11427 hashes_cnt++;
11428 }
11429 }
11430
11431 myfree (line_buf);
11432
11433 fclose (fp);
11434
11435 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11436
11437 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11438 }
11439 }
11440 else
11441 {
11442 if (isSalted)
11443 {
11444 hashes_buf[0].salt->salt_len = 8;
11445
11446 // special salt handling
11447
11448 switch (hash_mode)
11449 {
11450 case 1500: hashes_buf[0].salt->salt_len = 2;
11451 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11452 break;
11453 case 1731: hashes_buf[0].salt->salt_len = 4;
11454 break;
11455 case 2410: hashes_buf[0].salt->salt_len = 4;
11456 break;
11457 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11458 break;
11459 case 3100: hashes_buf[0].salt->salt_len = 1;
11460 break;
11461 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11462 break;
11463 case 5800: hashes_buf[0].salt->salt_len = 16;
11464 break;
11465 case 6800: hashes_buf[0].salt->salt_len = 32;
11466 break;
11467 case 8400: hashes_buf[0].salt->salt_len = 40;
11468 break;
11469 case 8800: hashes_buf[0].salt->salt_len = 16;
11470 break;
11471 case 8900: hashes_buf[0].salt->salt_len = 16;
11472 hashes_buf[0].salt->scrypt_N = 1024;
11473 hashes_buf[0].salt->scrypt_r = 1;
11474 hashes_buf[0].salt->scrypt_p = 1;
11475 break;
11476 case 9100: hashes_buf[0].salt->salt_len = 16;
11477 break;
11478 case 9300: hashes_buf[0].salt->salt_len = 14;
11479 hashes_buf[0].salt->scrypt_N = 16384;
11480 hashes_buf[0].salt->scrypt_r = 1;
11481 hashes_buf[0].salt->scrypt_p = 1;
11482 break;
11483 case 9400: hashes_buf[0].salt->salt_len = 16;
11484 break;
11485 case 9500: hashes_buf[0].salt->salt_len = 16;
11486 break;
11487 case 9600: hashes_buf[0].salt->salt_len = 16;
11488 break;
11489 case 9700: hashes_buf[0].salt->salt_len = 16;
11490 break;
11491 case 9710: hashes_buf[0].salt->salt_len = 16;
11492 break;
11493 case 9720: hashes_buf[0].salt->salt_len = 16;
11494 break;
11495 case 9800: hashes_buf[0].salt->salt_len = 16;
11496 break;
11497 case 9810: hashes_buf[0].salt->salt_len = 16;
11498 break;
11499 case 9820: hashes_buf[0].salt->salt_len = 16;
11500 break;
11501 case 10300: hashes_buf[0].salt->salt_len = 12;
11502 break;
11503 case 11500: hashes_buf[0].salt->salt_len = 4;
11504 break;
11505 case 11600: hashes_buf[0].salt->salt_len = 4;
11506 break;
11507 case 12400: hashes_buf[0].salt->salt_len = 4;
11508 break;
11509 case 12500: hashes_buf[0].salt->salt_len = 8;
11510 break;
11511 case 12600: hashes_buf[0].salt->salt_len = 64;
11512 break;
11513 }
11514
11515 // special esalt handling
11516
11517 switch (hash_mode)
11518 {
11519 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11520 break;
11521 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11522 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11523 break;
11524 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11525 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11526 break;
11527 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11528 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11529 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11530 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11531 break;
11532 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11533 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11534 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11535 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11536 break;
11537 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11538 break;
11539 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11540 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11541 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11542 break;
11543 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11544 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11545 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11546 break;
11547 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11548 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11549 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11550 break;
11551 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11552 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11553 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11554 break;
11555 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11556 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11557 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11558 break;
11559 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11560 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11561 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11562 break;
11563 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11564 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11565 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11566 break;
11567 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11568 break;
11569 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11570 break;
11571 }
11572 }
11573
11574 // set hashfile
11575
11576 switch (hash_mode)
11577 {
11578 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11579 break;
11580 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11581 break;
11582 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11583 break;
11584 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11585 break;
11586 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11587 break;
11588 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11589 break;
11590 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11591 break;
11592 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11593 break;
11594 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11595 break;
11596 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11597 break;
11598 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11599 break;
11600 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11601 break;
11602 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11603 break;
11604 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11605 break;
11606 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11607 break;
11608 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11609 break;
11610 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11611 break;
11612 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11613 break;
11614 }
11615
11616 // set default iterations
11617
11618 switch (hash_mode)
11619 {
11620 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11621 break;
11622 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11623 break;
11624 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11625 break;
11626 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11627 break;
11628 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11629 break;
11630 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11631 break;
11632 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11633 break;
11634 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11635 break;
11636 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11637 break;
11638 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11639 break;
11640 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11641 break;
11642 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11643 break;
11644 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11645 break;
11646 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11647 break;
11648 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11649 break;
11650 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11651 break;
11652 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11653 break;
11654 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11655 break;
11656 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11657 break;
11658 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11659 break;
11660 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11661 break;
11662 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11663 break;
11664 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11665 break;
11666 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11667 break;
11668 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11669 break;
11670 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11671 break;
11672 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11673 break;
11674 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11675 break;
11676 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11677 break;
11678 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11679 break;
11680 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11681 break;
11682 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11683 break;
11684 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11685 break;
11686 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11687 break;
11688 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11689 break;
11690 case 8900: hashes_buf[0].salt->salt_iter = 1;
11691 break;
11692 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11693 break;
11694 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11695 break;
11696 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11697 break;
11698 case 9300: hashes_buf[0].salt->salt_iter = 1;
11699 break;
11700 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11701 break;
11702 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11703 break;
11704 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11705 break;
11706 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11707 break;
11708 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11709 break;
11710 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11711 break;
11712 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11713 break;
11714 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11715 break;
11716 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11717 break;
11718 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11719 break;
11720 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11721 break;
11722 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11723 break;
11724 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11725 break;
11726 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11727 break;
11728 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11729 break;
11730 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11731 break;
11732 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11733 break;
11734 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11735 break;
11736 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11737 break;
11738 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11739 break;
11740 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11741 break;
11742 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11743 break;
11744 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11745 break;
11746 }
11747
11748 hashes_cnt = 1;
11749 }
11750
11751 if (show == 1 || left == 1)
11752 {
11753 for (uint i = 0; i < pot_cnt; i++)
11754 {
11755 pot_t *pot_ptr = &pot[i];
11756
11757 hash_t *hashes_buf = &pot_ptr->hash;
11758
11759 local_free (hashes_buf->digest);
11760
11761 if (isSalted)
11762 {
11763 local_free (hashes_buf->salt);
11764 }
11765 }
11766
11767 local_free (pot);
11768
11769 if (data.quiet == 0) log_info_nn ("");
11770
11771 return (0);
11772 }
11773
11774 if (keyspace == 0)
11775 {
11776 if (hashes_cnt == 0)
11777 {
11778 log_error ("ERROR: No hashes loaded");
11779
11780 return (-1);
11781 }
11782 }
11783
11784 /**
11785 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11786 */
11787
11788 if (data.outfile != NULL)
11789 {
11790 if (data.hashfile != NULL)
11791 {
11792 #ifdef _POSIX
11793 struct stat tmpstat_outfile;
11794 struct stat tmpstat_hashfile;
11795 #endif
11796
11797 #ifdef _WIN
11798 struct stat64 tmpstat_outfile;
11799 struct stat64 tmpstat_hashfile;
11800 #endif
11801
11802 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11803
11804 if (tmp_outfile_fp)
11805 {
11806 #ifdef _POSIX
11807 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11808 #endif
11809
11810 #ifdef _WIN
11811 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11812 #endif
11813
11814 fclose (tmp_outfile_fp);
11815 }
11816
11817 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11818
11819 if (tmp_hashfile_fp)
11820 {
11821 #ifdef _POSIX
11822 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11823 #endif
11824
11825 #ifdef _WIN
11826 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11827 #endif
11828
11829 fclose (tmp_hashfile_fp);
11830 }
11831
11832 if (tmp_outfile_fp && tmp_outfile_fp)
11833 {
11834 tmpstat_outfile.st_mode = 0;
11835 tmpstat_outfile.st_nlink = 0;
11836 tmpstat_outfile.st_uid = 0;
11837 tmpstat_outfile.st_gid = 0;
11838 tmpstat_outfile.st_rdev = 0;
11839 tmpstat_outfile.st_atime = 0;
11840
11841 tmpstat_hashfile.st_mode = 0;
11842 tmpstat_hashfile.st_nlink = 0;
11843 tmpstat_hashfile.st_uid = 0;
11844 tmpstat_hashfile.st_gid = 0;
11845 tmpstat_hashfile.st_rdev = 0;
11846 tmpstat_hashfile.st_atime = 0;
11847
11848 #ifdef _POSIX
11849 tmpstat_outfile.st_blksize = 0;
11850 tmpstat_outfile.st_blocks = 0;
11851
11852 tmpstat_hashfile.st_blksize = 0;
11853 tmpstat_hashfile.st_blocks = 0;
11854 #endif
11855
11856 #ifdef _POSIX
11857 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11858 {
11859 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11860
11861 return (-1);
11862 }
11863 #endif
11864
11865 #ifdef _WIN
11866 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11867 {
11868 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11869
11870 return (-1);
11871 }
11872 #endif
11873 }
11874 }
11875 }
11876
11877 /**
11878 * Remove duplicates
11879 */
11880
11881 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11882
11883 if (isSalted)
11884 {
11885 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11886 }
11887 else
11888 {
11889 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11890 }
11891
11892 uint hashes_cnt_orig = hashes_cnt;
11893
11894 hashes_cnt = 1;
11895
11896 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11897 {
11898 if (isSalted)
11899 {
11900 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11901 {
11902 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11903 }
11904 }
11905 else
11906 {
11907 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11908 }
11909
11910 if (hashes_pos > hashes_cnt)
11911 {
11912 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11913 }
11914
11915 hashes_cnt++;
11916 }
11917
11918 /**
11919 * Potfile removes
11920 */
11921
11922 uint potfile_remove_cracks = 0;
11923
11924 if (potfile_disable == 0)
11925 {
11926 hash_t hash_buf;
11927
11928 hash_buf.digest = mymalloc (dgst_size);
11929 hash_buf.salt = NULL;
11930 hash_buf.esalt = NULL;
11931 hash_buf.hash_info = NULL;
11932 hash_buf.cracked = 0;
11933
11934 if (isSalted)
11935 {
11936 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11937 }
11938
11939 if (esalt_size)
11940 {
11941 hash_buf.esalt = mymalloc (esalt_size);
11942 }
11943
11944 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11945
11946 // no solution for these special hash types (for instane because they use hashfile in output etc)
11947 if ((hash_mode != 5200) &&
11948 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11949 (hash_mode != 9000))
11950 {
11951 FILE *fp = fopen (potfile, "rb");
11952
11953 if (fp != NULL)
11954 {
11955 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11956
11957 // to be safe work with a copy (because of line_len loop, i etc)
11958 // moved up here because it's easier to handle continue case
11959 // it's just 64kb
11960
11961 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11962
11963 while (!feof (fp))
11964 {
11965 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11966
11967 if (ptr == NULL) break;
11968
11969 int line_len = strlen (line_buf);
11970
11971 if (line_len == 0) continue;
11972
11973 int iter = MAX_CUT_TRIES;
11974
11975 for (int i = line_len - 1; i && iter; i--, line_len--)
11976 {
11977 if (line_buf[i] != ':') continue;
11978
11979 if (isSalted)
11980 {
11981 memset (hash_buf.salt, 0, sizeof (salt_t));
11982 }
11983
11984 hash_t *found = NULL;
11985
11986 if (hash_mode == 6800)
11987 {
11988 if (i < 64) // 64 = 16 * uint in salt_buf[]
11989 {
11990 // manipulate salt_buf
11991 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11992
11993 hash_buf.salt->salt_len = i;
11994
11995 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11996 }
11997 }
11998 else if (hash_mode == 2500)
11999 {
12000 if (i < 64) // 64 = 16 * uint in salt_buf[]
12001 {
12002 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12003 // manipulate salt_buf
12004
12005 memcpy (line_buf_cpy, line_buf, i);
12006
12007 char *mac2_pos = strrchr (line_buf_cpy, ':');
12008
12009 if (mac2_pos == NULL) continue;
12010
12011 mac2_pos[0] = 0;
12012 mac2_pos++;
12013
12014 if (strlen (mac2_pos) != 12) continue;
12015
12016 char *mac1_pos = strrchr (line_buf_cpy, ':');
12017
12018 if (mac1_pos == NULL) continue;
12019
12020 mac1_pos[0] = 0;
12021 mac1_pos++;
12022
12023 if (strlen (mac1_pos) != 12) continue;
12024
12025 uint essid_length = mac1_pos - line_buf_cpy - 1;
12026
12027 // here we need the ESSID
12028 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12029
12030 hash_buf.salt->salt_len = essid_length;
12031
12032 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12033
12034 if (found)
12035 {
12036 wpa_t *wpa = (wpa_t *) found->esalt;
12037
12038 // compare hex string(s) vs binary MAC address(es)
12039
12040 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12041 {
12042 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12043 {
12044 found = NULL;
12045
12046 break;
12047 }
12048 }
12049
12050 // early skip ;)
12051 if (!found) continue;
12052
12053 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12054 {
12055 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12056 {
12057 found = NULL;
12058
12059 break;
12060 }
12061 }
12062 }
12063 }
12064 }
12065 else
12066 {
12067 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12068
12069 if (parser_status == PARSER_OK)
12070 {
12071 if (isSalted)
12072 {
12073 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12074 }
12075 else
12076 {
12077 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12078 }
12079 }
12080 }
12081
12082 if (found == NULL) continue;
12083
12084 if (!found->cracked) potfile_remove_cracks++;
12085
12086 found->cracked = 1;
12087
12088 if (found) break;
12089
12090 iter--;
12091 }
12092 }
12093
12094 myfree (line_buf_cpy);
12095
12096 myfree (line_buf);
12097
12098 fclose (fp);
12099 }
12100 }
12101
12102 if (esalt_size)
12103 {
12104 local_free (hash_buf.esalt);
12105 }
12106
12107 if (isSalted)
12108 {
12109 local_free (hash_buf.salt);
12110 }
12111
12112 local_free (hash_buf.digest);
12113 }
12114
12115 /**
12116 * Now generate all the buffers required for later
12117 */
12118
12119 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12120
12121 salt_t *salts_buf_new = NULL;
12122 void *esalts_buf_new = NULL;
12123
12124 if (isSalted)
12125 {
12126 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12127
12128 if (esalt_size)
12129 {
12130 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12131 }
12132 }
12133 else
12134 {
12135 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12136 }
12137
12138 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12139
12140 uint digests_cnt = hashes_cnt;
12141 uint digests_done = 0;
12142
12143 size_t size_digests = digests_cnt * dgst_size;
12144 size_t size_shown = digests_cnt * sizeof (uint);
12145
12146 uint *digests_shown = (uint *) mymalloc (size_shown);
12147 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12148
12149 uint salts_cnt = 0;
12150 uint salts_done = 0;
12151
12152 hashinfo_t **hash_info = NULL;
12153
12154 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12155 {
12156 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12157
12158 if (username && (remove || show))
12159 {
12160 uint user_pos;
12161
12162 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12163 {
12164 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12165
12166 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12167 }
12168 }
12169 }
12170
12171 uint *salts_shown = (uint *) mymalloc (size_shown);
12172
12173 salt_t *salt_buf;
12174
12175 {
12176 // copied from inner loop
12177
12178 salt_buf = &salts_buf_new[salts_cnt];
12179
12180 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12181
12182 if (esalt_size)
12183 {
12184 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12185 }
12186
12187 salt_buf->digests_cnt = 0;
12188 salt_buf->digests_done = 0;
12189 salt_buf->digests_offset = 0;
12190
12191 salts_cnt++;
12192 }
12193
12194 if (hashes_buf[0].cracked == 1)
12195 {
12196 digests_shown[0] = 1;
12197
12198 digests_done++;
12199
12200 salt_buf->digests_done++;
12201 }
12202
12203 salt_buf->digests_cnt++;
12204
12205 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12206
12207 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12208 {
12209 hash_info[0] = hashes_buf[0].hash_info;
12210 }
12211
12212 // copy from inner loop
12213
12214 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12215 {
12216 if (isSalted)
12217 {
12218 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12219 {
12220 salt_buf = &salts_buf_new[salts_cnt];
12221
12222 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12223
12224 if (esalt_size)
12225 {
12226 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12227 }
12228
12229 salt_buf->digests_cnt = 0;
12230 salt_buf->digests_done = 0;
12231 salt_buf->digests_offset = hashes_pos;
12232
12233 salts_cnt++;
12234 }
12235 }
12236
12237 if (hashes_buf[hashes_pos].cracked == 1)
12238 {
12239 digests_shown[hashes_pos] = 1;
12240
12241 digests_done++;
12242
12243 salt_buf->digests_done++;
12244 }
12245
12246 salt_buf->digests_cnt++;
12247
12248 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12249
12250 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12251 {
12252 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12253 }
12254 }
12255
12256 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12257 {
12258 salt_t *salt_buf = &salts_buf_new[salt_pos];
12259
12260 if (salt_buf->digests_done == salt_buf->digests_cnt)
12261 {
12262 salts_shown[salt_pos] = 1;
12263
12264 salts_done++;
12265 }
12266
12267 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12268 }
12269
12270 local_free (digests_buf);
12271 local_free (salts_buf);
12272 local_free (esalts_buf);
12273
12274 digests_buf = digests_buf_new;
12275 salts_buf = salts_buf_new;
12276 esalts_buf = esalts_buf_new;
12277
12278 local_free (hashes_buf);
12279
12280 /**
12281 * special modification not set from parser
12282 */
12283
12284 switch (hash_mode)
12285 {
12286 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12287 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12288 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12289 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12290 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12291 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12292 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12293 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12294 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12295 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12296 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12297 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12298 }
12299
12300 if (truecrypt_keyfiles)
12301 {
12302 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12303
12304 char *keyfiles = strdup (truecrypt_keyfiles);
12305
12306 char *keyfile = strtok (keyfiles, ",");
12307
12308 do
12309 {
12310 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12311
12312 } while ((keyfile = strtok (NULL, ",")) != NULL);
12313
12314 free (keyfiles);
12315 }
12316
12317 data.digests_cnt = digests_cnt;
12318 data.digests_done = digests_done;
12319 data.digests_buf = digests_buf;
12320 data.digests_shown = digests_shown;
12321 data.digests_shown_tmp = digests_shown_tmp;
12322
12323 data.salts_cnt = salts_cnt;
12324 data.salts_done = salts_done;
12325 data.salts_buf = salts_buf;
12326 data.salts_shown = salts_shown;
12327
12328 data.esalts_buf = esalts_buf;
12329 data.hash_info = hash_info;
12330
12331 /**
12332 * Automatic Optimizers
12333 */
12334
12335 if (salts_cnt == 1)
12336 opti_type |= OPTI_TYPE_SINGLE_SALT;
12337
12338 if (digests_cnt == 1)
12339 opti_type |= OPTI_TYPE_SINGLE_HASH;
12340
12341 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12342 opti_type |= OPTI_TYPE_NOT_ITERATED;
12343
12344 if (attack_mode == ATTACK_MODE_BF)
12345 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12346
12347 data.opti_type = opti_type;
12348
12349 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12350 {
12351 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12352 {
12353 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12354 {
12355 if (opts_type & OPTS_TYPE_ST_ADD80)
12356 {
12357 opts_type &= ~OPTS_TYPE_ST_ADD80;
12358 opts_type |= OPTS_TYPE_PT_ADD80;
12359 }
12360
12361 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12362 {
12363 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12364 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12365 }
12366
12367 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12368 {
12369 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12370 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12371 }
12372 }
12373 }
12374 }
12375
12376 /**
12377 * Some algorithm, like descrypt, can benefit from JIT compilation
12378 */
12379
12380 int force_jit_compilation = -1;
12381
12382 if (hash_mode == 8900)
12383 {
12384 force_jit_compilation = 8900;
12385 }
12386 else if (hash_mode == 9300)
12387 {
12388 force_jit_compilation = 8900;
12389 }
12390 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12391 {
12392 force_jit_compilation = 1500;
12393 }
12394
12395 /**
12396 * generate bitmap tables
12397 */
12398
12399 const uint bitmap_shift1 = 5;
12400 const uint bitmap_shift2 = 13;
12401
12402 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12403
12404 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12405 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12406 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12407 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12408 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12409 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12410 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12411 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12412
12413 uint bitmap_bits;
12414 uint bitmap_nums;
12415 uint bitmap_mask;
12416 uint bitmap_size;
12417
12418 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12419 {
12420 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12421
12422 bitmap_nums = 1 << bitmap_bits;
12423
12424 bitmap_mask = bitmap_nums - 1;
12425
12426 bitmap_size = bitmap_nums * sizeof (uint);
12427
12428 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12429
12430 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;
12431 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;
12432
12433 break;
12434 }
12435
12436 bitmap_nums = 1 << bitmap_bits;
12437
12438 bitmap_mask = bitmap_nums - 1;
12439
12440 bitmap_size = bitmap_nums * sizeof (uint);
12441
12442 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);
12443 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);
12444
12445 /**
12446 * prepare quick rule
12447 */
12448
12449 data.rule_buf_l = rule_buf_l;
12450 data.rule_buf_r = rule_buf_r;
12451
12452 int rule_len_l = (int) strlen (rule_buf_l);
12453 int rule_len_r = (int) strlen (rule_buf_r);
12454
12455 data.rule_len_l = rule_len_l;
12456 data.rule_len_r = rule_len_r;
12457
12458 /**
12459 * load rules
12460 */
12461
12462 uint *all_kernel_rules_cnt = NULL;
12463
12464 kernel_rule_t **all_kernel_rules_buf = NULL;
12465
12466 if (rp_files_cnt)
12467 {
12468 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12469
12470 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12471 }
12472
12473 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12474
12475 int rule_len = 0;
12476
12477 for (uint i = 0; i < rp_files_cnt; i++)
12478 {
12479 uint kernel_rules_avail = 0;
12480
12481 uint kernel_rules_cnt = 0;
12482
12483 kernel_rule_t *kernel_rules_buf = NULL;
12484
12485 char *rp_file = rp_files[i];
12486
12487 char in[BLOCK_SIZE] = { 0 };
12488 char out[BLOCK_SIZE] = { 0 };
12489
12490 FILE *fp = NULL;
12491
12492 uint rule_line = 0;
12493
12494 if ((fp = fopen (rp_file, "rb")) == NULL)
12495 {
12496 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12497
12498 return (-1);
12499 }
12500
12501 while (!feof (fp))
12502 {
12503 memset (rule_buf, 0, HCBUFSIZ);
12504
12505 rule_len = fgetl (fp, rule_buf);
12506
12507 rule_line++;
12508
12509 if (rule_len == 0) continue;
12510
12511 if (rule_buf[0] == '#') continue;
12512
12513 if (kernel_rules_avail == kernel_rules_cnt)
12514 {
12515 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12516
12517 kernel_rules_avail += INCR_RULES;
12518 }
12519
12520 memset (in, 0, BLOCK_SIZE);
12521 memset (out, 0, BLOCK_SIZE);
12522
12523 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12524
12525 if (result == -1)
12526 {
12527 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12528
12529 continue;
12530 }
12531
12532 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12533 {
12534 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12535
12536 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12537
12538 continue;
12539 }
12540
12541 /* its so slow
12542 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12543 {
12544 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12545
12546 continue;
12547 }
12548 */
12549
12550 kernel_rules_cnt++;
12551 }
12552
12553 fclose (fp);
12554
12555 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12556
12557 all_kernel_rules_buf[i] = kernel_rules_buf;
12558 }
12559
12560 /**
12561 * merge rules or automatic rule generator
12562 */
12563
12564 uint kernel_rules_cnt = 0;
12565
12566 kernel_rule_t *kernel_rules_buf = NULL;
12567
12568 if (attack_mode == ATTACK_MODE_STRAIGHT)
12569 {
12570 if (rp_files_cnt)
12571 {
12572 kernel_rules_cnt = 1;
12573
12574 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12575
12576 repeats[0] = kernel_rules_cnt;
12577
12578 for (uint i = 0; i < rp_files_cnt; i++)
12579 {
12580 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12581
12582 repeats[i + 1] = kernel_rules_cnt;
12583 }
12584
12585 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12586
12587 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12588
12589 for (uint i = 0; i < kernel_rules_cnt; i++)
12590 {
12591 uint out_pos = 0;
12592
12593 kernel_rule_t *out = &kernel_rules_buf[i];
12594
12595 for (uint j = 0; j < rp_files_cnt; j++)
12596 {
12597 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12598 uint in_pos;
12599
12600 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12601
12602 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12603 {
12604 if (out_pos == RULES_MAX - 1)
12605 {
12606 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12607
12608 break;
12609 }
12610
12611 out->cmds[out_pos] = in->cmds[in_pos];
12612 }
12613 }
12614 }
12615
12616 local_free (repeats);
12617 }
12618 else if (rp_gen)
12619 {
12620 uint kernel_rules_avail = 0;
12621
12622 while (kernel_rules_cnt < rp_gen)
12623 {
12624 if (kernel_rules_avail == kernel_rules_cnt)
12625 {
12626 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12627
12628 kernel_rules_avail += INCR_RULES;
12629 }
12630
12631 memset (rule_buf, 0, HCBUFSIZ);
12632
12633 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12634
12635 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12636
12637 kernel_rules_cnt++;
12638 }
12639 }
12640 }
12641
12642 myfree (rule_buf);
12643
12644 /**
12645 * generate NOP rules
12646 */
12647
12648 if (kernel_rules_cnt == 0)
12649 {
12650 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12651
12652 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12653
12654 kernel_rules_cnt++;
12655 }
12656
12657 data.kernel_rules_cnt = kernel_rules_cnt;
12658 data.kernel_rules_buf = kernel_rules_buf;
12659
12660 /**
12661 * OpenCL platforms: detect
12662 */
12663
12664 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12665 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12666
12667 cl_uint platforms_cnt = 0;
12668 cl_uint platform_devices_cnt = 0;
12669
12670 if (keyspace == 0)
12671 {
12672 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12673
12674 if (platforms_cnt == 0)
12675 {
12676 log_error ("ERROR: No OpenCL compatible platform found");
12677
12678 return (-1);
12679 }
12680
12681 if (opencl_platforms_filter != (uint) -1)
12682 {
12683 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12684
12685 if (opencl_platforms_filter > platform_cnt_mask)
12686 {
12687 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12688
12689 return (-1);
12690 }
12691 }
12692 }
12693
12694 /**
12695 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12696 */
12697
12698 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12699 {
12700 cl_platform_id platform = platforms[platform_id];
12701
12702 char platform_vendor[INFOSZ] = { 0 };
12703
12704 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12705
12706 #ifdef HAVE_HWMON
12707 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12708 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12709 {
12710 // make sure that we do not directly control the fan for NVidia
12711
12712 gpu_temp_retain = 0;
12713
12714 data.gpu_temp_retain = gpu_temp_retain;
12715 }
12716 #endif // HAVE_NVML || HAVE_NVAPI
12717 #endif
12718 }
12719
12720 /**
12721 * OpenCL devices: simply push all devices from all platforms into the same device array
12722 */
12723
12724 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12725
12726 data.devices_param = devices_param;
12727
12728 uint devices_cnt = 0;
12729
12730 uint devices_active = 0;
12731
12732 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12733 {
12734 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12735
12736 cl_platform_id platform = platforms[platform_id];
12737
12738 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12739
12740 char platform_vendor[INFOSZ] = { 0 };
12741
12742 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12743
12744 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
12745 // this causes trouble with vendor id based macros
12746 // we'll assign generic to those without special optimization available
12747
12748 cl_uint vendor_id = 0;
12749
12750 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
12751 {
12752 vendor_id = VENDOR_ID_AMD;
12753 }
12754 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
12755 {
12756 vendor_id = VENDOR_ID_GENERIC;
12757 }
12758 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
12759 {
12760 vendor_id = VENDOR_ID_GENERIC;
12761 }
12762 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
12763 {
12764 vendor_id = VENDOR_ID_GENERIC;
12765 }
12766 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
12767 {
12768 vendor_id = VENDOR_ID_GENERIC;
12769 }
12770 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12771 {
12772 vendor_id = VENDOR_ID_NV;
12773 }
12774 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
12775 {
12776 vendor_id = VENDOR_ID_GENERIC;
12777 }
12778 else
12779 {
12780 vendor_id = VENDOR_ID_GENERIC;
12781 }
12782
12783 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12784 {
12785 size_t param_value_size = 0;
12786
12787 const uint device_id = devices_cnt;
12788
12789 hc_device_param_t *device_param = &data.devices_param[device_id];
12790
12791 device_param->vendor_id = vendor_id;
12792
12793 device_param->device = platform_devices[platform_devices_id];
12794
12795 device_param->device_id = device_id;
12796
12797 device_param->platform_devices_id = platform_devices_id;
12798
12799 // device_type
12800
12801 cl_device_type device_type;
12802
12803 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12804
12805 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12806
12807 device_param->device_type = device_type;
12808
12809 // device_name
12810
12811 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12812
12813 char *device_name = (char *) mymalloc (param_value_size);
12814
12815 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12816
12817 device_param->device_name = device_name;
12818
12819 // tuning db
12820
12821 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12822
12823 // device_version
12824
12825 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12826
12827 char *device_version = (char *) mymalloc (param_value_size);
12828
12829 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12830
12831 device_param->device_version = device_version;
12832
12833 // device_opencl_version
12834
12835 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12836
12837 char *device_opencl_version = (char *) mymalloc (param_value_size);
12838
12839 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12840
12841 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12842
12843 myfree (device_opencl_version);
12844
12845 // vector_width
12846
12847 cl_uint vector_width;
12848
12849 if (opencl_vector_width_chgd == 0)
12850 {
12851 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12852 {
12853 if (opti_type & OPTI_TYPE_USES_BITS_64)
12854 {
12855 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12856 }
12857 else
12858 {
12859 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12860 }
12861 }
12862 else
12863 {
12864 vector_width = (cl_uint) tuningdb_entry->vector_width;
12865 }
12866 }
12867 else
12868 {
12869 vector_width = opencl_vector_width;
12870 }
12871
12872 if (vector_width > 16) vector_width = 16;
12873
12874 device_param->vector_width = vector_width;
12875
12876 // max_compute_units
12877
12878 cl_uint device_processors;
12879
12880 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12881
12882 device_param->device_processors = device_processors;
12883
12884 // device_maxmem_alloc
12885 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
12886
12887 cl_ulong device_maxmem_alloc;
12888
12889 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12890
12891 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
12892
12893 // device_global_mem
12894
12895 cl_ulong device_global_mem;
12896
12897 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12898
12899 device_param->device_global_mem = device_global_mem;
12900
12901 // max_work_group_size
12902
12903 size_t device_maxworkgroup_size;
12904
12905 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
12906
12907 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
12908
12909 // max_clock_frequency
12910
12911 cl_uint device_maxclock_frequency;
12912
12913 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12914
12915 device_param->device_maxclock_frequency = device_maxclock_frequency;
12916
12917 // skipped
12918
12919 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12920 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12921
12922 device_param->skipped = (skipped1 || skipped2);
12923
12924 // driver_version
12925 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12926
12927 char *driver_version = (char *) mymalloc (param_value_size);
12928
12929 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12930
12931 device_param->driver_version = driver_version;
12932
12933 // device_name_chksum
12934
12935 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12936
12937 #if __x86_64__
12938 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);
12939 #else
12940 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);
12941 #endif
12942
12943 uint device_name_digest[4] = { 0 };
12944
12945 md5_64 ((uint *) device_name_chksum, device_name_digest);
12946
12947 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12948
12949 device_param->device_name_chksum = device_name_chksum;
12950
12951 // device_processor_cores
12952
12953 if (device_type & CL_DEVICE_TYPE_CPU)
12954 {
12955 cl_uint device_processor_cores = 1;
12956
12957 device_param->device_processor_cores = device_processor_cores;
12958 }
12959
12960 if (device_type & CL_DEVICE_TYPE_GPU)
12961 {
12962 if (vendor_id == VENDOR_ID_AMD)
12963 {
12964 cl_uint device_processor_cores = 0;
12965
12966 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12967
12968 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12969
12970 device_param->device_processor_cores = device_processor_cores;
12971 }
12972 else if (vendor_id == VENDOR_ID_NV)
12973 {
12974 cl_uint kernel_exec_timeout = 0;
12975
12976 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12977
12978 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12979
12980 device_param->kernel_exec_timeout = kernel_exec_timeout;
12981
12982 cl_uint device_processor_cores = 0;
12983
12984 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12985
12986 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12987
12988 device_param->device_processor_cores = device_processor_cores;
12989
12990 cl_uint sm_minor = 0;
12991 cl_uint sm_major = 0;
12992
12993 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12994 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12995
12996 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12997 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12998
12999 device_param->sm_minor = sm_minor;
13000 device_param->sm_major = sm_major;
13001 }
13002 else
13003 {
13004 cl_uint device_processor_cores = 1;
13005
13006 device_param->device_processor_cores = device_processor_cores;
13007 }
13008 }
13009
13010 // display results
13011
13012 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13013 {
13014 if (device_param->skipped == 0)
13015 {
13016 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13017 device_id + 1,
13018 device_name,
13019 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13020 (unsigned int) (device_global_mem / 1024 / 1024),
13021 (unsigned int) (device_maxclock_frequency),
13022 (unsigned int) device_processors);
13023 }
13024 else
13025 {
13026 log_info ("Device #%u: %s, skipped",
13027 device_id + 1,
13028 device_name);
13029 }
13030 }
13031
13032 // common driver check
13033
13034 if (device_param->skipped == 0)
13035 {
13036 if (device_type & CL_DEVICE_TYPE_GPU)
13037 {
13038 if (vendor_id == VENDOR_ID_AMD)
13039 {
13040 int catalyst_check = (force == 1) ? 0 : 1;
13041
13042 int catalyst_warn = 0;
13043
13044 int catalyst_broken = 0;
13045
13046 if (catalyst_check == 1)
13047 {
13048 catalyst_warn = 1;
13049
13050 // v14.9 and higher
13051 if (atoi (device_param->driver_version) >= 1573)
13052 {
13053 catalyst_warn = 0;
13054 }
13055
13056 catalyst_check = 0;
13057 }
13058
13059 if (catalyst_broken == 1)
13060 {
13061 log_info ("");
13062 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13063 log_info ("It will pass over cracked hashes and does not report them as cracked");
13064 log_info ("You are STRONGLY encouraged not to use it");
13065 log_info ("You can use --force to override this but do not post error reports if you do so");
13066 log_info ("");
13067
13068 return (-1);
13069 }
13070
13071 if (catalyst_warn == 1)
13072 {
13073 log_info ("");
13074 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13075 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13076 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13077 #ifdef _WIN
13078 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13079 #endif
13080 log_info ("You can use --force to override this but do not post error reports if you do so");
13081 log_info ("");
13082
13083 return (-1);
13084 }
13085 }
13086 else if (vendor_id == VENDOR_ID_NV)
13087 {
13088 if (device_param->kernel_exec_timeout != 0)
13089 {
13090 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);
13091 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13092 }
13093 }
13094 }
13095
13096 if (device_type & CL_DEVICE_TYPE_CPU)
13097 {
13098 if (vendor_id == VENDOR_ID_AMD)
13099 {
13100 if (force == 0)
13101 {
13102 log_info ("");
13103 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13104 log_info ("You are STRONGLY encouraged not to use it");
13105 log_info ("You can use --force to override this but do not post error reports if you do so");
13106 log_info ("A good alternative is the free pocl, but make sure to use a version >= 3.8");
13107 log_info ("");
13108
13109 return (-1);
13110 }
13111 }
13112 }
13113
13114 /**
13115 * kernel accel and loops tuning db adjustment
13116 */
13117
13118 device_param->kernel_accel_min = 1;
13119 device_param->kernel_accel_max = 1024;
13120
13121 device_param->kernel_loops_min = 1;
13122 device_param->kernel_loops_max = 1024;
13123
13124 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13125
13126 if (tuningdb_entry)
13127 {
13128 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13129 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13130
13131 if (_kernel_accel)
13132 {
13133 device_param->kernel_accel_min = _kernel_accel;
13134 device_param->kernel_accel_max = _kernel_accel;
13135 }
13136
13137 if (_kernel_loops)
13138 {
13139 if (workload_profile == 1)
13140 {
13141 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13142 }
13143 else if (workload_profile == 2)
13144 {
13145 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13146 }
13147
13148 device_param->kernel_loops_min = _kernel_loops;
13149 device_param->kernel_loops_max = _kernel_loops;
13150 }
13151 }
13152
13153 // commandline parameters overwrite tuningdb entries
13154
13155 if (kernel_accel)
13156 {
13157 device_param->kernel_accel_min = kernel_accel;
13158 device_param->kernel_accel_max = kernel_accel;
13159 }
13160
13161 if (kernel_loops)
13162 {
13163 device_param->kernel_loops_min = kernel_loops;
13164 device_param->kernel_loops_max = kernel_loops;
13165 }
13166
13167 /**
13168 * activate device
13169 */
13170
13171 devices_active++;
13172 }
13173
13174 // next please
13175
13176 devices_cnt++;
13177 }
13178 }
13179
13180 if (keyspace == 0 && devices_active == 0)
13181 {
13182 log_error ("ERROR: No devices found/left");
13183
13184 return (-1);
13185 }
13186
13187 // 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)
13188
13189 if (devices_filter != (uint) -1)
13190 {
13191 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13192
13193 if (devices_filter > devices_cnt_mask)
13194 {
13195 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13196
13197 return (-1);
13198 }
13199 }
13200
13201 data.devices_cnt = devices_cnt;
13202
13203 data.devices_active = devices_active;
13204
13205 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13206 {
13207 log_info ("");
13208 }
13209
13210 /**
13211 * HM devices: init
13212 */
13213
13214 #ifdef HAVE_HWMON
13215 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13216 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13217 #endif
13218
13219 #ifdef HAVE_ADL
13220 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13221 #endif
13222
13223 if (gpu_temp_disable == 0)
13224 {
13225 #if defined(WIN) && defined(HAVE_NVAPI)
13226 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13227
13228 if (nvapi_init (nvapi) == 0)
13229 data.hm_nv = nvapi;
13230
13231 if (data.hm_nv)
13232 {
13233 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13234 {
13235 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13236
13237 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13238
13239 int tmp_out = 0;
13240
13241 for (int i = 0; i < tmp_in; i++)
13242 {
13243 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13244 }
13245
13246 for (int i = 0; i < tmp_out; i++)
13247 {
13248 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13249
13250 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13251
13252 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;
13253 }
13254 }
13255 }
13256 #endif // WIN && HAVE_NVAPI
13257
13258 #if defined(LINUX) && defined(HAVE_NVML)
13259 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13260
13261 if (nvml_init (nvml) == 0)
13262 data.hm_nv = nvml;
13263
13264 if (data.hm_nv)
13265 {
13266 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13267 {
13268 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13269
13270 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13271
13272 int tmp_out = 0;
13273
13274 for (int i = 0; i < tmp_in; i++)
13275 {
13276 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13277 }
13278
13279 for (int i = 0; i < tmp_out; i++)
13280 {
13281 unsigned int speed;
13282
13283 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;
13284 }
13285 }
13286 }
13287 #endif // LINUX && HAVE_NVML
13288
13289 data.hm_amd = NULL;
13290
13291 #ifdef HAVE_ADL
13292 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13293
13294 if (adl_init (adl) == 0)
13295 data.hm_amd = adl;
13296
13297 if (data.hm_amd)
13298 {
13299 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13300 {
13301 // total number of adapters
13302
13303 int hm_adapters_num;
13304
13305 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13306
13307 // adapter info
13308
13309 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13310
13311 if (lpAdapterInfo == NULL) return (-1);
13312
13313 // get a list (of ids of) valid/usable adapters
13314
13315 int num_adl_adapters = 0;
13316
13317 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13318
13319 if (num_adl_adapters > 0)
13320 {
13321 hc_thread_mutex_lock (mux_adl);
13322
13323 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13324
13325 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13326
13327 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13328 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13329
13330 hc_thread_mutex_unlock (mux_adl);
13331 }
13332
13333 myfree (valid_adl_device_list);
13334 myfree (lpAdapterInfo);
13335 }
13336 }
13337 #endif // HAVE_ADL
13338
13339 if (data.hm_amd == NULL && data.hm_nv == NULL)
13340 {
13341 gpu_temp_disable = 1;
13342 }
13343 }
13344
13345 /**
13346 * OpenCL devices: allocate buffer for device specific information
13347 */
13348
13349 #ifdef HAVE_HWMON
13350 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13351
13352 #ifdef HAVE_ADL
13353 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13354
13355 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13356 #endif // ADL
13357 #endif
13358
13359 /**
13360 * enable custom signal handler(s)
13361 */
13362
13363 if (benchmark == 0)
13364 {
13365 hc_signal (sigHandler_default);
13366 }
13367 else
13368 {
13369 hc_signal (sigHandler_benchmark);
13370 }
13371
13372 /**
13373 * User-defined GPU temp handling
13374 */
13375
13376 #ifdef HAVE_HWMON
13377 if (gpu_temp_disable == 1)
13378 {
13379 gpu_temp_abort = 0;
13380 gpu_temp_retain = 0;
13381 }
13382
13383 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13384 {
13385 if (gpu_temp_abort < gpu_temp_retain)
13386 {
13387 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13388
13389 return (-1);
13390 }
13391 }
13392
13393 data.gpu_temp_disable = gpu_temp_disable;
13394 data.gpu_temp_abort = gpu_temp_abort;
13395 data.gpu_temp_retain = gpu_temp_retain;
13396 #endif
13397
13398 /**
13399 * inform the user
13400 */
13401
13402 if (data.quiet == 0)
13403 {
13404 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13405
13406 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);
13407
13408 if (attack_mode == ATTACK_MODE_STRAIGHT)
13409 {
13410 log_info ("Rules: %u", kernel_rules_cnt);
13411 }
13412
13413 if (opti_type)
13414 {
13415 log_info ("Applicable Optimizers:");
13416
13417 for (uint i = 0; i < 32; i++)
13418 {
13419 const uint opti_bit = 1u << i;
13420
13421 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13422 }
13423 }
13424
13425 /**
13426 * Watchdog and Temperature balance
13427 */
13428
13429 #ifdef HAVE_HWMON
13430 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13431 {
13432 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13433 }
13434
13435 if (gpu_temp_abort == 0)
13436 {
13437 log_info ("Watchdog: Temperature abort trigger disabled");
13438 }
13439 else
13440 {
13441 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13442 }
13443
13444 if (gpu_temp_retain == 0)
13445 {
13446 log_info ("Watchdog: Temperature retain trigger disabled");
13447 }
13448 else
13449 {
13450 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13451 }
13452 #endif
13453 }
13454
13455 if (data.quiet == 0) log_info ("");
13456
13457 /**
13458 * HM devices: copy
13459 */
13460
13461 if (gpu_temp_disable == 0)
13462 {
13463 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13464 {
13465 hc_device_param_t *device_param = &data.devices_param[device_id];
13466
13467 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13468
13469 if (device_param->skipped) continue;
13470
13471 const uint platform_devices_id = device_param->platform_devices_id;
13472
13473 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13474 if (device_param->vendor_id == VENDOR_ID_NV)
13475 {
13476 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13477 }
13478 #endif
13479
13480 #ifdef HAVE_ADL
13481 if (device_param->vendor_id == VENDOR_ID_AMD)
13482 {
13483 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13484 }
13485 #endif
13486 }
13487 }
13488
13489 /*
13490 * Temporary fix:
13491 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13492 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13493 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13494 * Driver / ADL bug?
13495 */
13496
13497 #ifdef HAVE_ADL
13498 if (powertune_enable == 1)
13499 {
13500 hc_thread_mutex_lock (mux_adl);
13501
13502 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13503 {
13504 hc_device_param_t *device_param = &data.devices_param[device_id];
13505
13506 if (device_param->skipped) continue;
13507
13508 if (data.hm_device[device_id].od_version == 6)
13509 {
13510 // set powertune value only
13511
13512 int powertune_supported = 0;
13513
13514 int ADL_rc = 0;
13515
13516 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13517 {
13518 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13519
13520 return (-1);
13521 }
13522
13523 if (powertune_supported != 0)
13524 {
13525 // powertune set
13526 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13527
13528 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13529 {
13530 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13531
13532 return (-1);
13533 }
13534
13535 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13536 {
13537 log_error ("ERROR: Failed to set new ADL PowerControl values");
13538
13539 return (-1);
13540 }
13541 }
13542 }
13543 }
13544
13545 hc_thread_mutex_unlock (mux_adl);
13546 }
13547 #endif // HAVE_ADK
13548 #endif // HAVE_HWMON
13549
13550 #ifdef DEBUG
13551 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13552 #endif
13553
13554 uint kernel_power_all = 0;
13555
13556 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13557 {
13558 /**
13559 * host buffer
13560 */
13561
13562 hc_device_param_t *device_param = &data.devices_param[device_id];
13563
13564 if (device_param->skipped) continue;
13565
13566 /**
13567 * device properties
13568 */
13569
13570 const char *device_name_chksum = device_param->device_name_chksum;
13571 const u32 device_processors = device_param->device_processors;
13572 const u32 device_processor_cores = device_param->device_processor_cores;
13573
13574 /**
13575 * create context for each device
13576 */
13577
13578 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13579
13580 /**
13581 * create command-queue
13582 */
13583
13584 // not supported with NV
13585 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13586
13587 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13588
13589 /**
13590 * kernel threads: some algorithms need a fixed kernel-threads count
13591 * because of shared memory usage or bitslice
13592 * there needs to be some upper limit, otherwise there's too much overhead
13593 */
13594
13595 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
13596
13597 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
13598 {
13599 kernel_threads = KERNEL_THREADS_MAX_CPU;
13600 }
13601
13602 if (hash_mode == 1500) kernel_threads = 64; // DES
13603 if (hash_mode == 3000) kernel_threads = 64; // DES
13604 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
13605 if (hash_mode == 7500) kernel_threads = 64; // RC4
13606 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
13607 if (hash_mode == 9700) kernel_threads = 64; // RC4
13608 if (hash_mode == 9710) kernel_threads = 64; // RC4
13609 if (hash_mode == 9800) kernel_threads = 64; // RC4
13610 if (hash_mode == 9810) kernel_threads = 64; // RC4
13611 if (hash_mode == 10400) kernel_threads = 64; // RC4
13612 if (hash_mode == 10410) kernel_threads = 64; // RC4
13613 if (hash_mode == 10500) kernel_threads = 64; // RC4
13614 if (hash_mode == 13100) kernel_threads = 64; // RC4
13615
13616 /**
13617 * create input buffers on device : calculate size of fixed memory buffers
13618 */
13619
13620 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
13621 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13622
13623 device_param->size_root_css = size_root_css;
13624 device_param->size_markov_css = size_markov_css;
13625
13626 size_t size_results = kernel_threads * sizeof (uint);
13627
13628 device_param->size_results = size_results;
13629
13630 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13631 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13632
13633 size_t size_plains = digests_cnt * sizeof (plain_t);
13634 size_t size_salts = salts_cnt * sizeof (salt_t);
13635 size_t size_esalts = salts_cnt * esalt_size;
13636
13637 device_param->size_plains = size_plains;
13638 device_param->size_digests = size_digests;
13639 device_param->size_shown = size_shown;
13640 device_param->size_salts = size_salts;
13641
13642 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
13643 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
13644 size_t size_tm = 32 * sizeof (bs_word_t);
13645
13646 // scryptV stuff
13647
13648 size_t size_scryptV = 1;
13649
13650 if ((hash_mode == 8900) || (hash_mode == 9300))
13651 {
13652 uint tmto_start = 0;
13653 uint tmto_stop = 10;
13654
13655 if (scrypt_tmto)
13656 {
13657 tmto_start = scrypt_tmto;
13658 }
13659 else
13660 {
13661 // in case the user did not specify the tmto manually
13662 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13663 // but set the lower end only in case the user has a device with too less memory
13664
13665 if (hash_mode == 8900)
13666 {
13667 if (device_param->vendor_id == VENDOR_ID_AMD)
13668 {
13669 tmto_start = 1;
13670 }
13671 else if (device_param->vendor_id == VENDOR_ID_NV)
13672 {
13673 tmto_start = 3;
13674 }
13675 }
13676 else if (hash_mode == 9300)
13677 {
13678 if (device_param->vendor_id == VENDOR_ID_AMD)
13679 {
13680 tmto_start = 3;
13681 }
13682 else if (device_param->vendor_id == VENDOR_ID_NV)
13683 {
13684 tmto_start = 5;
13685 }
13686 }
13687 }
13688
13689 if (quiet == 0) log_info ("");
13690
13691 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13692 {
13693 // TODO: in theory the following calculation needs to be done per salt, not global
13694 // we assume all hashes have the same scrypt settings
13695
13696 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13697
13698 size_scryptV /= 1 << tmto;
13699
13700 size_scryptV *= device_processors * device_processor_cores;
13701
13702 if (size_scryptV > device_param->device_maxmem_alloc)
13703 {
13704 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13705
13706 continue;
13707 }
13708
13709 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13710 {
13711 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13712 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
13713 }
13714
13715 break;
13716 }
13717
13718 if (data.salts_buf[0].scrypt_phy == 0)
13719 {
13720 log_error ("ERROR: can't allocate enough device memory");
13721
13722 return -1;
13723 }
13724
13725 if (quiet == 0) log_info ("");
13726 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13727 }
13728
13729 /**
13730 * some algorithms need a fixed kernel-loops count
13731 */
13732
13733 if (hash_mode == 1500)
13734 {
13735 const u32 kernel_loops_fixed = 1024;
13736
13737 device_param->kernel_loops_min = kernel_loops_fixed;
13738 device_param->kernel_loops_max = kernel_loops_fixed;
13739 }
13740
13741 if (hash_mode == 3000)
13742 {
13743 const u32 kernel_loops_fixed = 1024;
13744
13745 device_param->kernel_loops_min = kernel_loops_fixed;
13746 device_param->kernel_loops_max = kernel_loops_fixed;
13747 }
13748
13749 if (hash_mode == 8900)
13750 {
13751 const u32 kernel_loops_fixed = 1;
13752
13753 device_param->kernel_loops_min = kernel_loops_fixed;
13754 device_param->kernel_loops_max = kernel_loops_fixed;
13755 }
13756
13757 if (hash_mode == 9300)
13758 {
13759 const u32 kernel_loops_fixed = 1;
13760
13761 device_param->kernel_loops_min = kernel_loops_fixed;
13762 device_param->kernel_loops_max = kernel_loops_fixed;
13763 }
13764
13765 if (hash_mode == 12500)
13766 {
13767 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13768
13769 device_param->kernel_loops_min = kernel_loops_fixed;
13770 device_param->kernel_loops_max = kernel_loops_fixed;
13771 }
13772
13773 /**
13774 * some algorithms have a maximum kernel-loops count
13775 */
13776
13777 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13778 {
13779 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13780 {
13781 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13782 }
13783 }
13784
13785 /**
13786 * some algorithms need a special kernel-accel
13787 */
13788
13789 if (hash_mode == 8900)
13790 {
13791 device_param->kernel_accel_min = 1;
13792 device_param->kernel_accel_max = 64;
13793 }
13794
13795 if (hash_mode == 9300)
13796 {
13797 device_param->kernel_accel_min = 1;
13798 device_param->kernel_accel_max = 64;
13799 }
13800
13801 u32 kernel_accel_min = device_param->kernel_accel_min;
13802 u32 kernel_accel_max = device_param->kernel_accel_max;
13803
13804 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13805
13806 size_t size_pws = 4;
13807 size_t size_tmps = 4;
13808 size_t size_hooks = 4;
13809
13810 while (kernel_accel_max >= kernel_accel_min)
13811 {
13812 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13813
13814 // size_pws
13815
13816 size_pws = kernel_power_max * sizeof (pw_t);
13817
13818 // size_tmps
13819
13820 switch (hash_mode)
13821 {
13822 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13823 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13824 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13825 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13826 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13827 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13828 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13829 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13830 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13831 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13832 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13833 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13834 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13835 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13836 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13837 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13838 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13839 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13840 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13841 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13842 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13843 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13844 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13845 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13846 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13847 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13848 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13849 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13850 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13851 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13852 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13853 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13854 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13855 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13856 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13857 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13858 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13859 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13860 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13861 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13862 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13863 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13864 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13865 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13866 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13867 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13868 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13869 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13870 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13871 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13872 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13873 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13874 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13875 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13876 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13877 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13878 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13879 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13880 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13881 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13882 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13883 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13884 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13885 };
13886
13887 // size_hooks
13888
13889 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13890 {
13891 // none yet
13892 }
13893
13894 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13895 // if not, decrease amplifier and try again
13896
13897 int skip = 0;
13898
13899 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13900 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13901 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13902
13903 if (( bitmap_size
13904 + bitmap_size
13905 + bitmap_size
13906 + bitmap_size
13907 + bitmap_size
13908 + bitmap_size
13909 + bitmap_size
13910 + bitmap_size
13911 + size_bfs
13912 + size_combs
13913 + size_digests
13914 + size_esalts
13915 + size_hooks
13916 + size_markov_css
13917 + size_plains
13918 + size_pws
13919 + size_pws // not a bug
13920 + size_results
13921 + size_root_css
13922 + size_rules
13923 + size_rules_c
13924 + size_salts
13925 + size_scryptV
13926 + size_shown
13927 + size_tm
13928 + size_tmps) > device_param->device_global_mem) skip = 1;
13929
13930 if (skip == 1)
13931 {
13932 kernel_accel_max--;
13933
13934 continue;
13935 }
13936
13937 break;
13938 }
13939
13940 /*
13941 if (kernel_accel_max == 0)
13942 {
13943 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13944
13945 return -1;
13946 }
13947 */
13948
13949 device_param->kernel_accel_min = kernel_accel_min;
13950 device_param->kernel_accel_max = kernel_accel_max;
13951
13952 /*
13953 if (kernel_accel_max < kernel_accel)
13954 {
13955 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13956
13957 device_param->kernel_accel = kernel_accel_max;
13958 }
13959 */
13960
13961 device_param->size_bfs = size_bfs;
13962 device_param->size_combs = size_combs;
13963 device_param->size_rules = size_rules;
13964 device_param->size_rules_c = size_rules_c;
13965 device_param->size_pws = size_pws;
13966 device_param->size_tmps = size_tmps;
13967 device_param->size_hooks = size_hooks;
13968
13969 // do not confuse kernel_accel_max with kernel_accel here
13970
13971 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13972
13973 device_param->kernel_threads = kernel_threads;
13974 device_param->kernel_power_user = kernel_power;
13975
13976 kernel_power_all += kernel_power;
13977
13978 /**
13979 * default building options
13980 */
13981
13982 char build_opts[1024] = { 0 };
13983
13984 // we don't have sm_* on vendors not NV but it doesn't matter
13985
13986 snprintf (build_opts, sizeof (build_opts) - 1, "-cl-std=CL1.1 -I\"%s/\" -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type);
13987
13988 /**
13989 * main kernel
13990 */
13991
13992 {
13993 /**
13994 * kernel source filename
13995 */
13996
13997 char source_file[256] = { 0 };
13998
13999 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14000
14001 struct stat sst;
14002
14003 if (stat (source_file, &sst) == -1)
14004 {
14005 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14006
14007 return -1;
14008 }
14009
14010 /**
14011 * kernel cached filename
14012 */
14013
14014 char cached_file[256] = { 0 };
14015
14016 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14017
14018 int cached = 1;
14019
14020 struct stat cst;
14021
14022 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14023 {
14024 cached = 0;
14025 }
14026
14027 /**
14028 * kernel compile or load
14029 */
14030
14031 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14032
14033 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14034
14035 if (force_jit_compilation == -1)
14036 {
14037 if (cached == 0)
14038 {
14039 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14040
14041 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14042
14043 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14044
14045 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14046
14047 #ifdef DEBUG
14048 size_t build_log_size = 0;
14049
14050 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14051
14052 if (build_log_size > 1)
14053 {
14054 char *build_log = (char *) malloc (build_log_size + 1);
14055
14056 memset (build_log, 0, build_log_size + 1);
14057
14058 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14059
14060 puts (build_log);
14061
14062 free (build_log);
14063 }
14064 #endif
14065
14066 if (rc != 0)
14067 {
14068 device_param->skipped = true;
14069 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14070 continue;
14071 }
14072
14073 size_t binary_size;
14074
14075 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14076
14077 u8 *binary = (u8 *) mymalloc (binary_size);
14078
14079 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14080
14081 writeProgramBin (cached_file, binary, binary_size);
14082
14083 local_free (binary);
14084 }
14085 else
14086 {
14087 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14088
14089 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14090
14091 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14092
14093 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14094 }
14095 }
14096 else
14097 {
14098 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14099
14100 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14101
14102 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14103
14104 char build_opts_update[1024] = { 0 };
14105
14106 if (force_jit_compilation == 1500)
14107 {
14108 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14109 }
14110 else if (force_jit_compilation == 8900)
14111 {
14112 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);
14113 }
14114 else
14115 {
14116 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14117 }
14118
14119 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14120
14121 #ifdef DEBUG
14122 size_t build_log_size = 0;
14123
14124 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14125
14126 if (build_log_size > 1)
14127 {
14128 char *build_log = (char *) malloc (build_log_size + 1);
14129
14130 memset (build_log, 0, build_log_size + 1);
14131
14132 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14133
14134 puts (build_log);
14135
14136 free (build_log);
14137 }
14138 #endif
14139
14140 if (rc != 0)
14141 {
14142 device_param->skipped = true;
14143
14144 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14145 }
14146 }
14147
14148 local_free (kernel_lengths);
14149 local_free (kernel_sources[0]);
14150 local_free (kernel_sources);
14151 }
14152
14153 /**
14154 * word generator kernel
14155 */
14156
14157 if (attack_mode != ATTACK_MODE_STRAIGHT)
14158 {
14159 /**
14160 * kernel mp source filename
14161 */
14162
14163 char source_file[256] = { 0 };
14164
14165 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14166
14167 struct stat sst;
14168
14169 if (stat (source_file, &sst) == -1)
14170 {
14171 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14172
14173 return -1;
14174 }
14175
14176 /**
14177 * kernel mp cached filename
14178 */
14179
14180 char cached_file[256] = { 0 };
14181
14182 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14183
14184 int cached = 1;
14185
14186 struct stat cst;
14187
14188 if (stat (cached_file, &cst) == -1)
14189 {
14190 cached = 0;
14191 }
14192
14193 /**
14194 * kernel compile or load
14195 */
14196
14197 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14198
14199 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14200
14201 if (cached == 0)
14202 {
14203 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14204
14205 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14206
14207 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14208
14209 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14210
14211 if (rc != 0)
14212 {
14213 device_param->skipped = true;
14214 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14215 continue;
14216 }
14217
14218 size_t binary_size;
14219
14220 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14221
14222 u8 *binary = (u8 *) mymalloc (binary_size);
14223
14224 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14225
14226 writeProgramBin (cached_file, binary, binary_size);
14227
14228 local_free (binary);
14229 }
14230 else
14231 {
14232 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14233
14234 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14235
14236 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14237
14238 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14239 }
14240
14241 local_free (kernel_lengths);
14242 local_free (kernel_sources[0]);
14243 local_free (kernel_sources);
14244 }
14245
14246 /**
14247 * amplifier kernel
14248 */
14249
14250 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14251 {
14252
14253 }
14254 else
14255 {
14256 /**
14257 * kernel amp source filename
14258 */
14259
14260 char source_file[256] = { 0 };
14261
14262 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14263
14264 struct stat sst;
14265
14266 if (stat (source_file, &sst) == -1)
14267 {
14268 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14269
14270 return -1;
14271 }
14272
14273 /**
14274 * kernel amp cached filename
14275 */
14276
14277 char cached_file[256] = { 0 };
14278
14279 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14280
14281 int cached = 1;
14282
14283 struct stat cst;
14284
14285 if (stat (cached_file, &cst) == -1)
14286 {
14287 cached = 0;
14288 }
14289
14290 /**
14291 * kernel compile or load
14292 */
14293
14294 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14295
14296 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14297
14298 if (cached == 0)
14299 {
14300 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14301
14302 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14303
14304 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14305
14306 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14307
14308 if (rc != 0)
14309 {
14310 device_param->skipped = true;
14311 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14312 continue;
14313 }
14314
14315 size_t binary_size;
14316
14317 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14318
14319 u8 *binary = (u8 *) mymalloc (binary_size);
14320
14321 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14322
14323 writeProgramBin (cached_file, binary, binary_size);
14324
14325 local_free (binary);
14326 }
14327 else
14328 {
14329 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14330
14331 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14332
14333 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14334
14335 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14336 }
14337
14338 local_free (kernel_lengths);
14339 local_free (kernel_sources[0]);
14340 local_free (kernel_sources);
14341 }
14342
14343 // some algorithm collide too fast, make that impossible
14344
14345 if (benchmark == 1)
14346 {
14347 ((uint *) digests_buf)[0] = -1;
14348 ((uint *) digests_buf)[1] = -1;
14349 ((uint *) digests_buf)[2] = -1;
14350 ((uint *) digests_buf)[3] = -1;
14351 }
14352
14353 /**
14354 * global buffers
14355 */
14356
14357 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14358 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14359 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14360 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14361 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14362 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14363 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14364 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14365 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14366 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14367 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14368 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14369 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14370 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14371 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14372 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14373 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14374 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14375
14376 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);
14377 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);
14378 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);
14379 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);
14380 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);
14381 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);
14382 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);
14383 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);
14384 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14385 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14386 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14387
14388 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14389 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14390 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14391 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14392 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14393 run_kernel_bzero (device_param, device_param->d_result, size_results);
14394
14395 /**
14396 * special buffers
14397 */
14398
14399 if (attack_kern == ATTACK_KERN_STRAIGHT)
14400 {
14401 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14402 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14403
14404 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14405
14406 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14407 }
14408 else if (attack_kern == ATTACK_KERN_COMBI)
14409 {
14410 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14411 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14412 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14413 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14414
14415 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14416 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14417 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14418 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14419 }
14420 else if (attack_kern == ATTACK_KERN_BF)
14421 {
14422 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14423 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14424 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14425 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14426 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14427
14428 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14429 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14430 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14431 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14432 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14433 }
14434
14435 if (size_esalts)
14436 {
14437 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14438
14439 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14440 }
14441
14442 /**
14443 * main host data
14444 */
14445
14446 uint *result = (uint *) mymalloc (size_results);
14447
14448 device_param->result = result;
14449
14450 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14451
14452 device_param->pws_buf = pws_buf;
14453
14454 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14455
14456 device_param->combs_buf = combs_buf;
14457
14458 void *hooks_buf = mymalloc (size_hooks);
14459
14460 device_param->hooks_buf = hooks_buf;
14461
14462 /**
14463 * kernel args
14464 */
14465
14466 device_param->kernel_params_buf32[21] = bitmap_mask;
14467 device_param->kernel_params_buf32[22] = bitmap_shift1;
14468 device_param->kernel_params_buf32[23] = bitmap_shift2;
14469 device_param->kernel_params_buf32[24] = 0; // salt_pos
14470 device_param->kernel_params_buf32[25] = 0; // loop_pos
14471 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14472 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14473 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14474 device_param->kernel_params_buf32[29] = 0; // digests_offset
14475 device_param->kernel_params_buf32[30] = 0; // combs_mode
14476 device_param->kernel_params_buf32[31] = 0; // gid_max
14477
14478 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14479 ? &device_param->d_pws_buf
14480 : &device_param->d_pws_amp_buf;
14481 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14482 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14483 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14484 device_param->kernel_params[ 4] = &device_param->d_tmps;
14485 device_param->kernel_params[ 5] = &device_param->d_hooks;
14486 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14487 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14488 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14489 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14490 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14491 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14492 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14493 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14494 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14495 device_param->kernel_params[15] = &device_param->d_digests_buf;
14496 device_param->kernel_params[16] = &device_param->d_digests_shown;
14497 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14498 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14499 device_param->kernel_params[19] = &device_param->d_result;
14500 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14501 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14502 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14503 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14504 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14505 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14506 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14507 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14508 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14509 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14510 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14511 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14512
14513 device_param->kernel_params_mp_buf64[3] = 0;
14514 device_param->kernel_params_mp_buf32[4] = 0;
14515 device_param->kernel_params_mp_buf32[5] = 0;
14516 device_param->kernel_params_mp_buf32[6] = 0;
14517 device_param->kernel_params_mp_buf32[7] = 0;
14518 device_param->kernel_params_mp_buf32[8] = 0;
14519
14520 device_param->kernel_params_mp[0] = NULL;
14521 device_param->kernel_params_mp[1] = NULL;
14522 device_param->kernel_params_mp[2] = NULL;
14523 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14524 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14525 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14526 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14527 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14528 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14529
14530 device_param->kernel_params_mp_l_buf64[3] = 0;
14531 device_param->kernel_params_mp_l_buf32[4] = 0;
14532 device_param->kernel_params_mp_l_buf32[5] = 0;
14533 device_param->kernel_params_mp_l_buf32[6] = 0;
14534 device_param->kernel_params_mp_l_buf32[7] = 0;
14535 device_param->kernel_params_mp_l_buf32[8] = 0;
14536 device_param->kernel_params_mp_l_buf32[9] = 0;
14537
14538 device_param->kernel_params_mp_l[0] = NULL;
14539 device_param->kernel_params_mp_l[1] = NULL;
14540 device_param->kernel_params_mp_l[2] = NULL;
14541 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14542 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14543 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14544 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14545 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14546 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14547 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14548
14549 device_param->kernel_params_mp_r_buf64[3] = 0;
14550 device_param->kernel_params_mp_r_buf32[4] = 0;
14551 device_param->kernel_params_mp_r_buf32[5] = 0;
14552 device_param->kernel_params_mp_r_buf32[6] = 0;
14553 device_param->kernel_params_mp_r_buf32[7] = 0;
14554 device_param->kernel_params_mp_r_buf32[8] = 0;
14555
14556 device_param->kernel_params_mp_r[0] = NULL;
14557 device_param->kernel_params_mp_r[1] = NULL;
14558 device_param->kernel_params_mp_r[2] = NULL;
14559 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14560 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14561 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14562 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14563 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14564 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14565
14566 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14567 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14568
14569 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14570 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14571 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14572 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14573 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14574 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14575 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14576
14577 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14578 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14579
14580 /**
14581 * kernel name
14582 */
14583
14584 char kernel_name[64] = { 0 };
14585
14586 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14587 {
14588 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14589 {
14590 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14591
14592 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14593
14594 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14595
14596 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14597
14598 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14599
14600 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14601 }
14602 else
14603 {
14604 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14605
14606 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14607
14608 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14609
14610 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14611
14612 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14613
14614 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14615 }
14616
14617 if (data.attack_mode == ATTACK_MODE_BF)
14618 {
14619 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14620 {
14621 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14622
14623 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14624 }
14625 }
14626 }
14627 else
14628 {
14629 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14630
14631 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14632
14633 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14634
14635 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14636
14637 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14638
14639 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14640
14641 if (opts_type & OPTS_TYPE_HOOK12)
14642 {
14643 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14644
14645 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14646 }
14647
14648 if (opts_type & OPTS_TYPE_HOOK23)
14649 {
14650 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14651
14652 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14653 }
14654 }
14655
14656 for (uint i = 0; i <= 20; i++)
14657 {
14658 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14659 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14660 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14661
14662 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14663 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14664 }
14665
14666 for (uint i = 21; i <= 31; i++)
14667 {
14668 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14669 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14670 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14671
14672 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14673 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14674 }
14675
14676 if (attack_mode == ATTACK_MODE_BF)
14677 {
14678 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14679 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14680
14681 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14682 {
14683 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14684 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14685 }
14686 }
14687 else if (attack_mode == ATTACK_MODE_HYBRID1)
14688 {
14689 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14690 }
14691 else if (attack_mode == ATTACK_MODE_HYBRID2)
14692 {
14693 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14694 }
14695
14696 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14697 {
14698 // nothing to do
14699 }
14700 else
14701 {
14702 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14703 }
14704
14705 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14706 {
14707 // nothing to do
14708 }
14709 else
14710 {
14711 for (uint i = 0; i < 5; i++)
14712 {
14713 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14714 }
14715
14716 for (uint i = 5; i < 7; i++)
14717 {
14718 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14719 }
14720 }
14721
14722 /**
14723 * Store initial fanspeed if gpu_temp_retain is enabled
14724 */
14725
14726 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14727 int gpu_temp_retain_set = 0;
14728
14729 if (gpu_temp_disable == 0)
14730 {
14731 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14732 {
14733 hc_thread_mutex_lock (mux_adl);
14734
14735 if (data.hm_device[device_id].fan_supported == 1)
14736 {
14737 if (gpu_temp_retain_chgd == 0)
14738 {
14739 uint cur_temp = 0;
14740 uint default_temp = 0;
14741
14742 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);
14743
14744 if (ADL_rc == ADL_OK)
14745 {
14746 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14747
14748 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14749
14750 // special case with multi gpu setups: always use minimum retain
14751
14752 if (gpu_temp_retain_set == 0)
14753 {
14754 gpu_temp_retain = gpu_temp_retain_target;
14755 gpu_temp_retain_set = 1;
14756 }
14757 else
14758 {
14759 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14760 }
14761
14762 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14763 }
14764 }
14765
14766 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14767
14768 temp_retain_fanspeed_value[device_id] = fan_speed;
14769
14770 if (fan_speed == -1)
14771 {
14772 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14773
14774 temp_retain_fanspeed_value[device_id] = 0;
14775 }
14776 }
14777
14778 hc_thread_mutex_unlock (mux_adl);
14779 }
14780 }
14781
14782 /**
14783 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14784 */
14785
14786 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14787 {
14788 hc_thread_mutex_lock (mux_adl);
14789
14790 if (data.hm_device[device_id].od_version == 6)
14791 {
14792 int ADL_rc;
14793
14794 // check powertune capabilities first, if not available then skip device
14795
14796 int powertune_supported = 0;
14797
14798 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14799 {
14800 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14801
14802 return (-1);
14803 }
14804
14805 if (powertune_supported != 0)
14806 {
14807 // powercontrol settings
14808
14809 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14810
14811 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14812 {
14813 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14814 }
14815
14816 if (ADL_rc != ADL_OK)
14817 {
14818 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14819
14820 return (-1);
14821 }
14822
14823 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14824 {
14825 log_error ("ERROR: Failed to set new ADL PowerControl values");
14826
14827 return (-1);
14828 }
14829
14830 // clocks
14831
14832 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14833
14834 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14835
14836 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)
14837 {
14838 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14839
14840 return (-1);
14841 }
14842
14843 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14844
14845 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14846
14847 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14848 {
14849 log_error ("ERROR: Failed to get ADL device capabilities");
14850
14851 return (-1);
14852 }
14853
14854 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14855 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14856
14857 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14858 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14859
14860 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14861 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14862
14863 // warning if profile has too low max values
14864
14865 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14866 {
14867 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14868 }
14869
14870 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14871 {
14872 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14873 }
14874
14875 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14876
14877 performance_state->iNumberOfPerformanceLevels = 2;
14878
14879 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14880 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14881 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14882 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14883
14884 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)
14885 {
14886 log_info ("ERROR: Failed to set ADL performance state");
14887
14888 return (-1);
14889 }
14890
14891 local_free (performance_state);
14892 }
14893 }
14894
14895 hc_thread_mutex_unlock (mux_adl);
14896 }
14897 #endif // HAVE_HWMON && HAVE_ADL
14898 }
14899
14900 data.kernel_power_all = kernel_power_all;
14901
14902 if (data.quiet == 0) log_info ("");
14903
14904 /**
14905 * In benchmark-mode, inform user which algorithm is checked
14906 */
14907
14908 if (benchmark == 1)
14909 {
14910 quiet = 0;
14911
14912 data.quiet = quiet;
14913
14914 char *hash_type = strhashtype (data.hash_mode); // not a bug
14915
14916 log_info ("Hashtype: %s", hash_type);
14917 log_info ("");
14918 }
14919
14920 /**
14921 * keep track of the progress
14922 */
14923
14924 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14925 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14926 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14927
14928 /**
14929 * open filehandles
14930 */
14931
14932 #if _WIN
14933 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14934 {
14935 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14936
14937 return (-1);
14938 }
14939
14940 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14941 {
14942 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14943
14944 return (-1);
14945 }
14946
14947 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14948 {
14949 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14950
14951 return (-1);
14952 }
14953 #endif
14954
14955 /**
14956 * dictionary pad
14957 */
14958
14959 segment_size *= (1024 * 1024);
14960
14961 data.segment_size = segment_size;
14962
14963 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14964
14965 wl_data->buf = (char *) mymalloc (segment_size);
14966 wl_data->avail = segment_size;
14967 wl_data->incr = segment_size;
14968 wl_data->cnt = 0;
14969 wl_data->pos = 0;
14970
14971 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14972
14973 data.wordlist_mode = wordlist_mode;
14974
14975 cs_t *css_buf = NULL;
14976 uint css_cnt = 0;
14977 uint dictcnt = 0;
14978 uint maskcnt = 1;
14979 char **masks = NULL;
14980 char **dictfiles = NULL;
14981
14982 uint mask_from_file = 0;
14983
14984 if (attack_mode == ATTACK_MODE_STRAIGHT)
14985 {
14986 if (wordlist_mode == WL_MODE_FILE)
14987 {
14988 int wls_left = myargc - (optind + 1);
14989
14990 for (int i = 0; i < wls_left; i++)
14991 {
14992 char *l0_filename = myargv[optind + 1 + i];
14993
14994 struct stat l0_stat;
14995
14996 if (stat (l0_filename, &l0_stat) == -1)
14997 {
14998 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14999
15000 return (-1);
15001 }
15002
15003 uint is_dir = S_ISDIR (l0_stat.st_mode);
15004
15005 if (is_dir == 0)
15006 {
15007 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15008
15009 dictcnt++;
15010
15011 dictfiles[dictcnt - 1] = l0_filename;
15012 }
15013 else
15014 {
15015 // do not allow --keyspace w/ a directory
15016
15017 if (keyspace == 1)
15018 {
15019 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15020
15021 return (-1);
15022 }
15023
15024 char **dictionary_files = NULL;
15025
15026 dictionary_files = scan_directory (l0_filename);
15027
15028 if (dictionary_files != NULL)
15029 {
15030 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15031
15032 for (int d = 0; dictionary_files[d] != NULL; d++)
15033 {
15034 char *l1_filename = dictionary_files[d];
15035
15036 struct stat l1_stat;
15037
15038 if (stat (l1_filename, &l1_stat) == -1)
15039 {
15040 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15041
15042 return (-1);
15043 }
15044
15045 if (S_ISREG (l1_stat.st_mode))
15046 {
15047 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15048
15049 dictcnt++;
15050
15051 dictfiles[dictcnt - 1] = strdup (l1_filename);
15052 }
15053 }
15054 }
15055
15056 local_free (dictionary_files);
15057 }
15058 }
15059
15060 if (dictcnt < 1)
15061 {
15062 log_error ("ERROR: No usable dictionary file found.");
15063
15064 return (-1);
15065 }
15066 }
15067 else if (wordlist_mode == WL_MODE_STDIN)
15068 {
15069 dictcnt = 1;
15070 }
15071 }
15072 else if (attack_mode == ATTACK_MODE_COMBI)
15073 {
15074 // display
15075
15076 char *dictfile1 = myargv[optind + 1 + 0];
15077 char *dictfile2 = myargv[optind + 1 + 1];
15078
15079 // find the bigger dictionary and use as base
15080
15081 FILE *fp1 = NULL;
15082 FILE *fp2 = NULL;
15083
15084 struct stat tmp_stat;
15085
15086 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15087 {
15088 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15089
15090 return (-1);
15091 }
15092
15093 if (stat (dictfile1, &tmp_stat) == -1)
15094 {
15095 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15096
15097 fclose (fp1);
15098
15099 return (-1);
15100 }
15101
15102 if (S_ISDIR (tmp_stat.st_mode))
15103 {
15104 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15105
15106 fclose (fp1);
15107
15108 return (-1);
15109 }
15110
15111 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15112 {
15113 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15114
15115 fclose (fp1);
15116
15117 return (-1);
15118 }
15119
15120 if (stat (dictfile2, &tmp_stat) == -1)
15121 {
15122 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15123
15124 fclose (fp1);
15125 fclose (fp2);
15126
15127 return (-1);
15128 }
15129
15130 if (S_ISDIR (tmp_stat.st_mode))
15131 {
15132 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15133
15134 fclose (fp1);
15135 fclose (fp2);
15136
15137 return (-1);
15138 }
15139
15140 data.combs_cnt = 1;
15141
15142 data.quiet = 1;
15143
15144 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15145
15146 data.quiet = quiet;
15147
15148 if (words1_cnt == 0)
15149 {
15150 log_error ("ERROR: %s: empty file", dictfile1);
15151
15152 fclose (fp1);
15153 fclose (fp2);
15154
15155 return (-1);
15156 }
15157
15158 data.combs_cnt = 1;
15159
15160 data.quiet = 1;
15161
15162 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15163
15164 data.quiet = quiet;
15165
15166 if (words2_cnt == 0)
15167 {
15168 log_error ("ERROR: %s: empty file", dictfile2);
15169
15170 fclose (fp1);
15171 fclose (fp2);
15172
15173 return (-1);
15174 }
15175
15176 fclose (fp1);
15177 fclose (fp2);
15178
15179 data.dictfile = dictfile1;
15180 data.dictfile2 = dictfile2;
15181
15182 if (words1_cnt >= words2_cnt)
15183 {
15184 data.combs_cnt = words2_cnt;
15185 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15186
15187 dictfiles = &data.dictfile;
15188
15189 dictcnt = 1;
15190 }
15191 else
15192 {
15193 data.combs_cnt = words1_cnt;
15194 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15195
15196 dictfiles = &data.dictfile2;
15197
15198 dictcnt = 1;
15199
15200 // we also have to switch wordlist related rules!
15201
15202 char *tmpc = data.rule_buf_l;
15203
15204 data.rule_buf_l = data.rule_buf_r;
15205 data.rule_buf_r = tmpc;
15206
15207 int tmpi = data.rule_len_l;
15208
15209 data.rule_len_l = data.rule_len_r;
15210 data.rule_len_r = tmpi;
15211 }
15212 }
15213 else if (attack_mode == ATTACK_MODE_BF)
15214 {
15215 char *mask = NULL;
15216
15217 maskcnt = 0;
15218
15219 if (benchmark == 0)
15220 {
15221 mask = myargv[optind + 1];
15222
15223 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15224
15225 if ((optind + 2) <= myargc)
15226 {
15227 struct stat file_stat;
15228
15229 if (stat (mask, &file_stat) == -1)
15230 {
15231 maskcnt = 1;
15232
15233 masks[maskcnt - 1] = mystrdup (mask);
15234 }
15235 else
15236 {
15237 int wls_left = myargc - (optind + 1);
15238
15239 uint masks_avail = INCR_MASKS;
15240
15241 for (int i = 0; i < wls_left; i++)
15242 {
15243 if (i != 0)
15244 {
15245 mask = myargv[optind + 1 + i];
15246
15247 if (stat (mask, &file_stat) == -1)
15248 {
15249 log_error ("ERROR: %s: %s", mask, strerror (errno));
15250
15251 return (-1);
15252 }
15253 }
15254
15255 uint is_file = S_ISREG (file_stat.st_mode);
15256
15257 if (is_file == 1)
15258 {
15259 FILE *mask_fp;
15260
15261 if ((mask_fp = fopen (mask, "r")) == NULL)
15262 {
15263 log_error ("ERROR: %s: %s", mask, strerror (errno));
15264
15265 return (-1);
15266 }
15267
15268 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15269
15270 while (!feof (mask_fp))
15271 {
15272 memset (line_buf, 0, HCBUFSIZ);
15273
15274 int line_len = fgetl (mask_fp, line_buf);
15275
15276 if (line_len == 0) continue;
15277
15278 if (line_buf[0] == '#') continue;
15279
15280 if (masks_avail == maskcnt)
15281 {
15282 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15283
15284 masks_avail += INCR_MASKS;
15285 }
15286
15287 masks[maskcnt] = mystrdup (line_buf);
15288
15289 maskcnt++;
15290 }
15291
15292 myfree (line_buf);
15293
15294 fclose (mask_fp);
15295 }
15296 else
15297 {
15298 log_error ("ERROR: %s: unsupported file-type", mask);
15299
15300 return (-1);
15301 }
15302 }
15303
15304 mask_from_file = 1;
15305 }
15306 }
15307 else
15308 {
15309 custom_charset_1 = (char *) "?l?d?u";
15310 custom_charset_2 = (char *) "?l?d";
15311 custom_charset_3 = (char *) "?l?d*!$@_";
15312
15313 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15314 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15315 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15316
15317 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15318
15319 wordlist_mode = WL_MODE_MASK;
15320
15321 data.wordlist_mode = wordlist_mode;
15322
15323 increment = 1;
15324
15325 maskcnt = 1;
15326 }
15327 }
15328 else
15329 {
15330 /**
15331 * generate full masks and charsets
15332 */
15333
15334 masks = (char **) mymalloc (sizeof (char *));
15335
15336 switch (hash_mode)
15337 {
15338 case 1731: pw_min = 5;
15339 pw_max = 5;
15340 mask = mystrdup ("?b?b?b?b?b");
15341 break;
15342 case 12500: pw_min = 5;
15343 pw_max = 5;
15344 mask = mystrdup ("?b?b?b?b?b");
15345 break;
15346 default: pw_min = 7;
15347 pw_max = 7;
15348 mask = mystrdup ("?b?b?b?b?b?b?b");
15349 break;
15350 }
15351
15352 maskcnt = 1;
15353
15354 masks[maskcnt - 1] = mystrdup (mask);
15355
15356 wordlist_mode = WL_MODE_MASK;
15357
15358 data.wordlist_mode = wordlist_mode;
15359
15360 increment = 1;
15361 }
15362
15363 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15364
15365 if (increment)
15366 {
15367 if (increment_min > pw_min) pw_min = increment_min;
15368
15369 if (increment_max < pw_max) pw_max = increment_max;
15370 }
15371 }
15372 else if (attack_mode == ATTACK_MODE_HYBRID1)
15373 {
15374 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15375
15376 // display
15377
15378 char *mask = myargv[myargc - 1];
15379
15380 maskcnt = 0;
15381
15382 masks = (char **) mymalloc (1 * sizeof (char *));
15383
15384 // mod
15385
15386 struct stat file_stat;
15387
15388 if (stat (mask, &file_stat) == -1)
15389 {
15390 maskcnt = 1;
15391
15392 masks[maskcnt - 1] = mystrdup (mask);
15393 }
15394 else
15395 {
15396 uint is_file = S_ISREG (file_stat.st_mode);
15397
15398 if (is_file == 1)
15399 {
15400 FILE *mask_fp;
15401
15402 if ((mask_fp = fopen (mask, "r")) == NULL)
15403 {
15404 log_error ("ERROR: %s: %s", mask, strerror (errno));
15405
15406 return (-1);
15407 }
15408
15409 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15410
15411 uint masks_avail = 1;
15412
15413 while (!feof (mask_fp))
15414 {
15415 memset (line_buf, 0, HCBUFSIZ);
15416
15417 int line_len = fgetl (mask_fp, line_buf);
15418
15419 if (line_len == 0) continue;
15420
15421 if (line_buf[0] == '#') continue;
15422
15423 if (masks_avail == maskcnt)
15424 {
15425 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15426
15427 masks_avail += INCR_MASKS;
15428 }
15429
15430 masks[maskcnt] = mystrdup (line_buf);
15431
15432 maskcnt++;
15433 }
15434
15435 myfree (line_buf);
15436
15437 fclose (mask_fp);
15438
15439 mask_from_file = 1;
15440 }
15441 else
15442 {
15443 maskcnt = 1;
15444
15445 masks[maskcnt - 1] = mystrdup (mask);
15446 }
15447 }
15448
15449 // base
15450
15451 int wls_left = myargc - (optind + 2);
15452
15453 for (int i = 0; i < wls_left; i++)
15454 {
15455 char *filename = myargv[optind + 1 + i];
15456
15457 struct stat file_stat;
15458
15459 if (stat (filename, &file_stat) == -1)
15460 {
15461 log_error ("ERROR: %s: %s", filename, strerror (errno));
15462
15463 return (-1);
15464 }
15465
15466 uint is_dir = S_ISDIR (file_stat.st_mode);
15467
15468 if (is_dir == 0)
15469 {
15470 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15471
15472 dictcnt++;
15473
15474 dictfiles[dictcnt - 1] = filename;
15475 }
15476 else
15477 {
15478 // do not allow --keyspace w/ a directory
15479
15480 if (keyspace == 1)
15481 {
15482 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15483
15484 return (-1);
15485 }
15486
15487 char **dictionary_files = NULL;
15488
15489 dictionary_files = scan_directory (filename);
15490
15491 if (dictionary_files != NULL)
15492 {
15493 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15494
15495 for (int d = 0; dictionary_files[d] != NULL; d++)
15496 {
15497 char *l1_filename = dictionary_files[d];
15498
15499 struct stat l1_stat;
15500
15501 if (stat (l1_filename, &l1_stat) == -1)
15502 {
15503 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15504
15505 return (-1);
15506 }
15507
15508 if (S_ISREG (l1_stat.st_mode))
15509 {
15510 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15511
15512 dictcnt++;
15513
15514 dictfiles[dictcnt - 1] = strdup (l1_filename);
15515 }
15516 }
15517 }
15518
15519 local_free (dictionary_files);
15520 }
15521 }
15522
15523 if (dictcnt < 1)
15524 {
15525 log_error ("ERROR: No usable dictionary file found.");
15526
15527 return (-1);
15528 }
15529
15530 if (increment)
15531 {
15532 maskcnt = 0;
15533
15534 uint mask_min = increment_min; // we can't reject smaller masks here
15535 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15536
15537 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15538 {
15539 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15540
15541 if (cur_mask == NULL) break;
15542
15543 masks[maskcnt] = cur_mask;
15544
15545 maskcnt++;
15546
15547 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15548 }
15549 }
15550 }
15551 else if (attack_mode == ATTACK_MODE_HYBRID2)
15552 {
15553 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15554
15555 // display
15556
15557 char *mask = myargv[optind + 1 + 0];
15558
15559 maskcnt = 0;
15560
15561 masks = (char **) mymalloc (1 * sizeof (char *));
15562
15563 // mod
15564
15565 struct stat file_stat;
15566
15567 if (stat (mask, &file_stat) == -1)
15568 {
15569 maskcnt = 1;
15570
15571 masks[maskcnt - 1] = mystrdup (mask);
15572 }
15573 else
15574 {
15575 uint is_file = S_ISREG (file_stat.st_mode);
15576
15577 if (is_file == 1)
15578 {
15579 FILE *mask_fp;
15580
15581 if ((mask_fp = fopen (mask, "r")) == NULL)
15582 {
15583 log_error ("ERROR: %s: %s", mask, strerror (errno));
15584
15585 return (-1);
15586 }
15587
15588 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15589
15590 uint masks_avail = 1;
15591
15592 while (!feof (mask_fp))
15593 {
15594 memset (line_buf, 0, HCBUFSIZ);
15595
15596 int line_len = fgetl (mask_fp, line_buf);
15597
15598 if (line_len == 0) continue;
15599
15600 if (line_buf[0] == '#') continue;
15601
15602 if (masks_avail == maskcnt)
15603 {
15604 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15605
15606 masks_avail += INCR_MASKS;
15607 }
15608
15609 masks[maskcnt] = mystrdup (line_buf);
15610
15611 maskcnt++;
15612 }
15613
15614 myfree (line_buf);
15615
15616 fclose (mask_fp);
15617
15618 mask_from_file = 1;
15619 }
15620 else
15621 {
15622 maskcnt = 1;
15623
15624 masks[maskcnt - 1] = mystrdup (mask);
15625 }
15626 }
15627
15628 // base
15629
15630 int wls_left = myargc - (optind + 2);
15631
15632 for (int i = 0; i < wls_left; i++)
15633 {
15634 char *filename = myargv[optind + 2 + i];
15635
15636 struct stat file_stat;
15637
15638 if (stat (filename, &file_stat) == -1)
15639 {
15640 log_error ("ERROR: %s: %s", filename, strerror (errno));
15641
15642 return (-1);
15643 }
15644
15645 uint is_dir = S_ISDIR (file_stat.st_mode);
15646
15647 if (is_dir == 0)
15648 {
15649 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15650
15651 dictcnt++;
15652
15653 dictfiles[dictcnt - 1] = filename;
15654 }
15655 else
15656 {
15657 // do not allow --keyspace w/ a directory
15658
15659 if (keyspace == 1)
15660 {
15661 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15662
15663 return (-1);
15664 }
15665
15666 char **dictionary_files = NULL;
15667
15668 dictionary_files = scan_directory (filename);
15669
15670 if (dictionary_files != NULL)
15671 {
15672 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15673
15674 for (int d = 0; dictionary_files[d] != NULL; d++)
15675 {
15676 char *l1_filename = dictionary_files[d];
15677
15678 struct stat l1_stat;
15679
15680 if (stat (l1_filename, &l1_stat) == -1)
15681 {
15682 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15683
15684 return (-1);
15685 }
15686
15687 if (S_ISREG (l1_stat.st_mode))
15688 {
15689 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15690
15691 dictcnt++;
15692
15693 dictfiles[dictcnt - 1] = strdup (l1_filename);
15694 }
15695 }
15696 }
15697
15698 local_free (dictionary_files);
15699 }
15700 }
15701
15702 if (dictcnt < 1)
15703 {
15704 log_error ("ERROR: No usable dictionary file found.");
15705
15706 return (-1);
15707 }
15708
15709 if (increment)
15710 {
15711 maskcnt = 0;
15712
15713 uint mask_min = increment_min; // we can't reject smaller masks here
15714 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15715
15716 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15717 {
15718 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15719
15720 if (cur_mask == NULL) break;
15721
15722 masks[maskcnt] = cur_mask;
15723
15724 maskcnt++;
15725
15726 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15727 }
15728 }
15729 }
15730
15731 data.pw_min = pw_min;
15732 data.pw_max = pw_max;
15733
15734 /**
15735 * weak hash check
15736 */
15737
15738 if (weak_hash_threshold >= salts_cnt)
15739 {
15740 hc_device_param_t *device_param = NULL;
15741
15742 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15743 {
15744 device_param = &data.devices_param[device_id];
15745
15746 if (device_param->skipped) continue;
15747
15748 break;
15749 }
15750
15751 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15752
15753 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15754 {
15755 weak_hash_check (device_param, salt_pos);
15756 }
15757 }
15758
15759 // Display hack, guarantee that there is at least one \r before real start
15760
15761 if (data.quiet == 0) log_info_nn ("");
15762
15763 /**
15764 * status and monitor threads
15765 */
15766
15767 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15768
15769 hc_thread_t i_thread = 0;
15770
15771 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15772 {
15773 hc_thread_create (i_thread, thread_keypress, &benchmark);
15774 }
15775
15776 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15777
15778 uint ni_threads_cnt = 0;
15779
15780 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15781
15782 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15783
15784 ni_threads_cnt++;
15785
15786 /**
15787 * Outfile remove
15788 */
15789
15790 if (keyspace == 0)
15791 {
15792 if (outfile_check_timer != 0)
15793 {
15794 if (data.outfile_check_directory != NULL)
15795 {
15796 if ((hash_mode != 5200) &&
15797 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15798 (hash_mode != 9000))
15799 {
15800 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15801
15802 ni_threads_cnt++;
15803 }
15804 else
15805 {
15806 outfile_check_timer = 0;
15807 }
15808 }
15809 else
15810 {
15811 outfile_check_timer = 0;
15812 }
15813 }
15814 }
15815
15816 /**
15817 * Inform the user if we got some hashes remove because of the pot file remove feature
15818 */
15819
15820 if (data.quiet == 0)
15821 {
15822 if (potfile_remove_cracks > 0)
15823 {
15824 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15825 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15826 }
15827 }
15828
15829 data.outfile_check_timer = outfile_check_timer;
15830
15831 /**
15832 * main loop
15833 */
15834
15835 char **induction_dictionaries = NULL;
15836
15837 int induction_dictionaries_cnt = 0;
15838
15839 hcstat_table_t *root_table_buf = NULL;
15840 hcstat_table_t *markov_table_buf = NULL;
15841
15842 uint initial_restore_done = 0;
15843
15844 data.maskcnt = maskcnt;
15845
15846 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15847 {
15848 if (data.devices_status == STATUS_CRACKED) break;
15849
15850 data.devices_status = STATUS_INIT;
15851
15852 if (maskpos > rd->maskpos)
15853 {
15854 rd->dictpos = 0;
15855 }
15856
15857 rd->maskpos = maskpos;
15858 data.maskpos = maskpos;
15859
15860 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15861 {
15862 char *mask = masks[maskpos];
15863
15864 if (mask_from_file == 1)
15865 {
15866 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15867
15868 char *str_ptr;
15869 uint str_pos;
15870
15871 uint mask_offset = 0;
15872
15873 uint separator_cnt;
15874
15875 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15876 {
15877 str_ptr = strstr (mask + mask_offset, ",");
15878
15879 if (str_ptr == NULL) break;
15880
15881 str_pos = str_ptr - mask;
15882
15883 // escaped separator, i.e. "\,"
15884
15885 if (str_pos > 0)
15886 {
15887 if (mask[str_pos - 1] == '\\')
15888 {
15889 separator_cnt --;
15890
15891 mask_offset = str_pos + 1;
15892
15893 continue;
15894 }
15895 }
15896
15897 // reset the offset
15898
15899 mask_offset = 0;
15900
15901 mask[str_pos] = '\0';
15902
15903 switch (separator_cnt)
15904 {
15905 case 0:
15906 mp_reset_usr (mp_usr, 0);
15907
15908 custom_charset_1 = mask;
15909 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15910 break;
15911
15912 case 1:
15913 mp_reset_usr (mp_usr, 1);
15914
15915 custom_charset_2 = mask;
15916 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15917 break;
15918
15919 case 2:
15920 mp_reset_usr (mp_usr, 2);
15921
15922 custom_charset_3 = mask;
15923 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15924 break;
15925
15926 case 3:
15927 mp_reset_usr (mp_usr, 3);
15928
15929 custom_charset_4 = mask;
15930 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15931 break;
15932 }
15933
15934 mask = mask + str_pos + 1;
15935 }
15936 }
15937
15938 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15939 {
15940 if (maskpos > 0)
15941 {
15942 local_free (css_buf);
15943 local_free (data.root_css_buf);
15944 local_free (data.markov_css_buf);
15945
15946 local_free (masks[maskpos - 1]);
15947 }
15948
15949 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15950
15951 data.mask = mask;
15952 data.css_cnt = css_cnt;
15953 data.css_buf = css_buf;
15954
15955 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15956
15957 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15958
15959 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15960 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15961
15962 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15963
15964 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15965
15966 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15967 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15968
15969 data.root_css_buf = root_css_buf;
15970 data.markov_css_buf = markov_css_buf;
15971
15972 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15973
15974 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15975
15976 local_free (root_table_buf);
15977 local_free (markov_table_buf);
15978
15979 // args
15980
15981 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15982 {
15983 hc_device_param_t *device_param = &data.devices_param[device_id];
15984
15985 if (device_param->skipped) continue;
15986
15987 device_param->kernel_params_mp[0] = &device_param->d_combs;
15988 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15989 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15990
15991 device_param->kernel_params_mp_buf64[3] = 0;
15992 device_param->kernel_params_mp_buf32[4] = css_cnt;
15993 device_param->kernel_params_mp_buf32[5] = 0;
15994 device_param->kernel_params_mp_buf32[6] = 0;
15995 device_param->kernel_params_mp_buf32[7] = 0;
15996
15997 if (attack_mode == ATTACK_MODE_HYBRID1)
15998 {
15999 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16000 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16001 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16002 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16003 }
16004 else if (attack_mode == ATTACK_MODE_HYBRID2)
16005 {
16006 device_param->kernel_params_mp_buf32[5] = 0;
16007 device_param->kernel_params_mp_buf32[6] = 0;
16008 device_param->kernel_params_mp_buf32[7] = 0;
16009 }
16010
16011 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]);
16012 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]);
16013 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]);
16014
16015 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);
16016 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);
16017 }
16018 }
16019 else if (attack_mode == ATTACK_MODE_BF)
16020 {
16021 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16022
16023 if (increment)
16024 {
16025 for (uint i = 0; i < dictcnt; i++)
16026 {
16027 local_free (dictfiles[i]);
16028 }
16029
16030 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16031 {
16032 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16033
16034 if (l1_filename == NULL) break;
16035
16036 dictcnt++;
16037
16038 dictfiles[dictcnt - 1] = l1_filename;
16039 }
16040 }
16041 else
16042 {
16043 dictcnt++;
16044
16045 dictfiles[dictcnt - 1] = mask;
16046 }
16047
16048 if (dictcnt == 0)
16049 {
16050 log_error ("ERROR: Mask is too small");
16051
16052 return (-1);
16053 }
16054 }
16055 }
16056
16057 free (induction_dictionaries);
16058
16059 // induction_dictionaries_cnt = 0; // implied
16060
16061 if (attack_mode != ATTACK_MODE_BF)
16062 {
16063 if (keyspace == 0)
16064 {
16065 induction_dictionaries = scan_directory (induction_directory);
16066
16067 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16068 }
16069 }
16070
16071 if (induction_dictionaries_cnt)
16072 {
16073 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16074 }
16075
16076 /**
16077 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16078 */
16079 if (keyspace == 1)
16080 {
16081 if ((maskcnt > 1) || (dictcnt > 1))
16082 {
16083 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16084
16085 return (-1);
16086 }
16087 }
16088
16089 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16090 {
16091 char *subid = logfile_generate_subid ();
16092
16093 data.subid = subid;
16094
16095 logfile_sub_msg ("START");
16096
16097 data.devices_status = STATUS_INIT;
16098
16099 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16100 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16101 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16102
16103 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16104
16105 data.cpt_pos = 0;
16106
16107 data.cpt_start = time (NULL);
16108
16109 data.cpt_total = 0;
16110
16111 if (data.restore == 0)
16112 {
16113 rd->words_cur = skip;
16114
16115 skip = 0;
16116
16117 data.skip = 0;
16118 }
16119
16120 data.ms_paused = 0;
16121
16122 data.words_cur = rd->words_cur;
16123
16124 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16125 {
16126 hc_device_param_t *device_param = &data.devices_param[device_id];
16127
16128 if (device_param->skipped) continue;
16129
16130 device_param->speed_pos = 0;
16131
16132 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16133 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16134
16135 device_param->exec_pos = 0;
16136
16137 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16138
16139 device_param->kernel_power = device_param->kernel_power_user;
16140
16141 device_param->outerloop_pos = 0;
16142 device_param->outerloop_left = 0;
16143 device_param->innerloop_pos = 0;
16144 device_param->innerloop_left = 0;
16145
16146 // some more resets:
16147
16148 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16149
16150 device_param->pws_cnt = 0;
16151
16152 device_param->words_off = 0;
16153 device_param->words_done = 0;
16154 }
16155
16156 data.kernel_power_div = 0;
16157
16158 // figure out some workload
16159
16160 if (attack_mode == ATTACK_MODE_STRAIGHT)
16161 {
16162 if (data.wordlist_mode == WL_MODE_FILE)
16163 {
16164 char *dictfile = NULL;
16165
16166 if (induction_dictionaries_cnt)
16167 {
16168 dictfile = induction_dictionaries[0];
16169 }
16170 else
16171 {
16172 dictfile = dictfiles[dictpos];
16173 }
16174
16175 data.dictfile = dictfile;
16176
16177 logfile_sub_string (dictfile);
16178
16179 for (uint i = 0; i < rp_files_cnt; i++)
16180 {
16181 logfile_sub_var_string ("rulefile", rp_files[i]);
16182 }
16183
16184 FILE *fd2 = fopen (dictfile, "rb");
16185
16186 if (fd2 == NULL)
16187 {
16188 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16189
16190 return (-1);
16191 }
16192
16193 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16194
16195 fclose (fd2);
16196
16197 if (data.words_cnt == 0)
16198 {
16199 if (data.devices_status == STATUS_CRACKED) break;
16200 if (data.devices_status == STATUS_ABORTED) break;
16201
16202 dictpos++;
16203
16204 continue;
16205 }
16206 }
16207 }
16208 else if (attack_mode == ATTACK_MODE_COMBI)
16209 {
16210 char *dictfile = data.dictfile;
16211 char *dictfile2 = data.dictfile2;
16212
16213 logfile_sub_string (dictfile);
16214 logfile_sub_string (dictfile2);
16215
16216 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16217 {
16218 FILE *fd2 = fopen (dictfile, "rb");
16219
16220 if (fd2 == NULL)
16221 {
16222 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16223
16224 return (-1);
16225 }
16226
16227 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16228
16229 fclose (fd2);
16230 }
16231 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16232 {
16233 FILE *fd2 = fopen (dictfile2, "rb");
16234
16235 if (fd2 == NULL)
16236 {
16237 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16238
16239 return (-1);
16240 }
16241
16242 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16243
16244 fclose (fd2);
16245 }
16246
16247 if (data.words_cnt == 0)
16248 {
16249 if (data.devices_status == STATUS_CRACKED) break;
16250 if (data.devices_status == STATUS_ABORTED) break;
16251
16252 dictpos++;
16253
16254 continue;
16255 }
16256 }
16257 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16258 {
16259 char *dictfile = NULL;
16260
16261 if (induction_dictionaries_cnt)
16262 {
16263 dictfile = induction_dictionaries[0];
16264 }
16265 else
16266 {
16267 dictfile = dictfiles[dictpos];
16268 }
16269
16270 data.dictfile = dictfile;
16271
16272 char *mask = data.mask;
16273
16274 logfile_sub_string (dictfile);
16275 logfile_sub_string (mask);
16276
16277 FILE *fd2 = fopen (dictfile, "rb");
16278
16279 if (fd2 == NULL)
16280 {
16281 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16282
16283 return (-1);
16284 }
16285
16286 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16287
16288 fclose (fd2);
16289
16290 if (data.words_cnt == 0)
16291 {
16292 if (data.devices_status == STATUS_CRACKED) break;
16293 if (data.devices_status == STATUS_ABORTED) break;
16294
16295 dictpos++;
16296
16297 continue;
16298 }
16299 }
16300 else if (attack_mode == ATTACK_MODE_BF)
16301 {
16302 local_free (css_buf);
16303 local_free (data.root_css_buf);
16304 local_free (data.markov_css_buf);
16305
16306 char *mask = dictfiles[dictpos];
16307
16308 logfile_sub_string (mask);
16309
16310 // base
16311
16312 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16313
16314 if (opts_type & OPTS_TYPE_PT_UNICODE)
16315 {
16316 uint css_cnt_unicode = css_cnt * 2;
16317
16318 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16319
16320 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16321 {
16322 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16323
16324 css_buf_unicode[j + 1].cs_buf[0] = 0;
16325 css_buf_unicode[j + 1].cs_len = 1;
16326 }
16327
16328 free (css_buf);
16329
16330 css_buf = css_buf_unicode;
16331 css_cnt = css_cnt_unicode;
16332 }
16333
16334 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16335
16336 uint mask_min = pw_min;
16337 uint mask_max = pw_max;
16338
16339 if (opts_type & OPTS_TYPE_PT_UNICODE)
16340 {
16341 mask_min *= 2;
16342 mask_max *= 2;
16343 }
16344
16345 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16346 {
16347 if (css_cnt < mask_min)
16348 {
16349 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16350 }
16351
16352 if (css_cnt > mask_max)
16353 {
16354 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16355 }
16356
16357 // skip to next mask
16358
16359 dictpos++;
16360
16361 rd->dictpos = dictpos;
16362
16363 logfile_sub_msg ("STOP");
16364
16365 continue;
16366 }
16367
16368 uint save_css_cnt = css_cnt;
16369
16370 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16371 {
16372 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16373 {
16374 uint salt_len = (uint) data.salts_buf[0].salt_len;
16375 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16376
16377 uint css_cnt_salt = css_cnt + salt_len;
16378
16379 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16380
16381 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16382
16383 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16384 {
16385 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16386 css_buf_salt[j].cs_len = 1;
16387 }
16388
16389 free (css_buf);
16390
16391 css_buf = css_buf_salt;
16392 css_cnt = css_cnt_salt;
16393 }
16394 }
16395
16396 data.mask = mask;
16397 data.css_cnt = css_cnt;
16398 data.css_buf = css_buf;
16399
16400 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16401
16402 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16403
16404 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16405
16406 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16407 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16408
16409 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16410
16411 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16412
16413 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16414 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16415
16416 data.root_css_buf = root_css_buf;
16417 data.markov_css_buf = markov_css_buf;
16418
16419 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16420
16421 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16422
16423 local_free (root_table_buf);
16424 local_free (markov_table_buf);
16425
16426 // copy + args
16427
16428 uint css_cnt_l = css_cnt;
16429 uint css_cnt_r;
16430
16431 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16432 {
16433 if (save_css_cnt < 6)
16434 {
16435 css_cnt_r = 1;
16436 }
16437 else if (save_css_cnt == 6)
16438 {
16439 css_cnt_r = 2;
16440 }
16441 else
16442 {
16443 if (opts_type & OPTS_TYPE_PT_UNICODE)
16444 {
16445 if (save_css_cnt == 8 || save_css_cnt == 10)
16446 {
16447 css_cnt_r = 2;
16448 }
16449 else
16450 {
16451 css_cnt_r = 4;
16452 }
16453 }
16454 else
16455 {
16456 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16457 {
16458 css_cnt_r = 3;
16459 }
16460 else
16461 {
16462 css_cnt_r = 4;
16463 }
16464 }
16465 }
16466 }
16467 else
16468 {
16469 css_cnt_r = 1;
16470
16471 /* unfinished code?
16472 int sum = css_buf[css_cnt_r - 1].cs_len;
16473
16474 for (uint i = 1; i < 4 && i < css_cnt; i++)
16475 {
16476 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16477
16478 css_cnt_r++;
16479
16480 sum *= css_buf[css_cnt_r - 1].cs_len;
16481 }
16482 */
16483 }
16484
16485 css_cnt_l -= css_cnt_r;
16486
16487 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16488
16489 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16490 {
16491 hc_device_param_t *device_param = &data.devices_param[device_id];
16492
16493 if (device_param->skipped) continue;
16494
16495 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16496 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16497 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16498
16499 device_param->kernel_params_mp_l_buf64[3] = 0;
16500 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16501 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16502 device_param->kernel_params_mp_l_buf32[6] = 0;
16503 device_param->kernel_params_mp_l_buf32[7] = 0;
16504 device_param->kernel_params_mp_l_buf32[8] = 0;
16505
16506 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16507 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16508 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16509 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16510
16511 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16512 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16513 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16514
16515 device_param->kernel_params_mp_r_buf64[3] = 0;
16516 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16517 device_param->kernel_params_mp_r_buf32[5] = 0;
16518 device_param->kernel_params_mp_r_buf32[6] = 0;
16519 device_param->kernel_params_mp_r_buf32[7] = 0;
16520
16521 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]);
16522 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]);
16523 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]);
16524
16525 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]);
16526 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]);
16527 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]);
16528
16529 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);
16530 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);
16531 }
16532 }
16533
16534 u64 words_base = data.words_cnt;
16535
16536 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16537 {
16538 if (data.kernel_rules_cnt)
16539 {
16540 words_base /= data.kernel_rules_cnt;
16541 }
16542 }
16543 else if (data.attack_kern == ATTACK_KERN_COMBI)
16544 {
16545 if (data.combs_cnt)
16546 {
16547 words_base /= data.combs_cnt;
16548 }
16549 }
16550 else if (data.attack_kern == ATTACK_KERN_BF)
16551 {
16552 if (data.bfs_cnt)
16553 {
16554 words_base /= data.bfs_cnt;
16555 }
16556 }
16557
16558 data.words_base = words_base;
16559
16560 if (keyspace == 1)
16561 {
16562 log_info ("%llu", (unsigned long long int) words_base);
16563
16564 return (0);
16565 }
16566
16567 if (data.words_cur > data.words_base)
16568 {
16569 log_error ("ERROR: restore value greater keyspace");
16570
16571 return (-1);
16572 }
16573
16574 if (data.words_cur)
16575 {
16576 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16577 {
16578 for (uint i = 0; i < data.salts_cnt; i++)
16579 {
16580 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16581 }
16582 }
16583 else if (data.attack_kern == ATTACK_KERN_COMBI)
16584 {
16585 for (uint i = 0; i < data.salts_cnt; i++)
16586 {
16587 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16588 }
16589 }
16590 else if (data.attack_kern == ATTACK_KERN_BF)
16591 {
16592 for (uint i = 0; i < data.salts_cnt; i++)
16593 {
16594 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16595 }
16596 }
16597 }
16598
16599 /*
16600 * Inform user about possible slow speeds
16601 */
16602
16603 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16604 {
16605 if (data.words_base < kernel_power_all)
16606 {
16607 if (quiet == 0)
16608 {
16609 log_info ("");
16610 log_info ("ATTENTION!");
16611 log_info (" The wordlist or mask you are using is too small.");
16612 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16613 log_info (" The cracking speed will drop.");
16614 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16615 log_info ("");
16616 }
16617 }
16618 }
16619
16620 /*
16621 * Update loopback file
16622 */
16623
16624 if (loopback == 1)
16625 {
16626 time_t now;
16627
16628 time (&now);
16629
16630 uint random_num = get_random_num (0, 9999);
16631
16632 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16633
16634 data.loopback_file = loopback_file;
16635 }
16636
16637 /*
16638 * Update dictionary statistic
16639 */
16640
16641 if (keyspace == 0)
16642 {
16643 dictstat_fp = fopen (dictstat, "wb");
16644
16645 if (dictstat_fp)
16646 {
16647 lock_file (dictstat_fp);
16648
16649 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16650
16651 fclose (dictstat_fp);
16652 }
16653 }
16654
16655 data.devices_status = STATUS_RUNNING;
16656
16657 if (initial_restore_done == 0)
16658 {
16659 if (data.restore_disable == 0) cycle_restore ();
16660
16661 initial_restore_done = 1;
16662 }
16663
16664 hc_timer_set (&data.timer_running);
16665
16666 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16667 {
16668 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16669 {
16670 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16671 if (quiet == 0) fflush (stdout);
16672 }
16673 }
16674 else if (wordlist_mode == WL_MODE_STDIN)
16675 {
16676 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16677 if (data.quiet == 0) log_info ("");
16678 }
16679
16680 time_t runtime_start;
16681
16682 time (&runtime_start);
16683
16684 data.runtime_start = runtime_start;
16685
16686 /**
16687 * create cracker threads
16688 */
16689
16690 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16691
16692 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16693 {
16694 hc_device_param_t *device_param = &devices_param[device_id];
16695
16696 if (wordlist_mode == WL_MODE_STDIN)
16697 {
16698 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16699 }
16700 else
16701 {
16702 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16703 }
16704 }
16705
16706 // wait for crack threads to exit
16707
16708 hc_thread_wait (data.devices_cnt, c_threads);
16709
16710 local_free (c_threads);
16711
16712 data.restore = 0;
16713
16714 // finalize task
16715
16716 logfile_sub_var_uint ("status-after-work", data.devices_status);
16717
16718 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16719
16720 if (data.devices_status == STATUS_CRACKED) break;
16721 if (data.devices_status == STATUS_ABORTED) break;
16722
16723 if (data.devices_status == STATUS_BYPASS)
16724 {
16725 data.devices_status = STATUS_RUNNING;
16726 }
16727
16728 if (induction_dictionaries_cnt)
16729 {
16730 unlink (induction_dictionaries[0]);
16731 }
16732
16733 free (induction_dictionaries);
16734
16735 if (attack_mode != ATTACK_MODE_BF)
16736 {
16737 induction_dictionaries = scan_directory (induction_directory);
16738
16739 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16740 }
16741
16742 if (benchmark == 0)
16743 {
16744 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16745 {
16746 if (quiet == 0) clear_prompt ();
16747
16748 if (quiet == 0) log_info ("");
16749
16750 if (status == 1)
16751 {
16752 status_display ();
16753 }
16754 else
16755 {
16756 if (quiet == 0) status_display ();
16757 }
16758
16759 if (quiet == 0) log_info ("");
16760 }
16761 }
16762
16763 if (attack_mode == ATTACK_MODE_BF)
16764 {
16765 dictpos++;
16766
16767 rd->dictpos = dictpos;
16768 }
16769 else
16770 {
16771 if (induction_dictionaries_cnt)
16772 {
16773 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16774 }
16775 else
16776 {
16777 dictpos++;
16778
16779 rd->dictpos = dictpos;
16780 }
16781 }
16782
16783 time_t runtime_stop;
16784
16785 time (&runtime_stop);
16786
16787 data.runtime_stop = runtime_stop;
16788
16789 logfile_sub_uint (runtime_start);
16790 logfile_sub_uint (runtime_stop);
16791
16792 logfile_sub_msg ("STOP");
16793
16794 global_free (subid);
16795 }
16796
16797 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16798
16799 if (data.devices_status == STATUS_CRACKED) break;
16800 if (data.devices_status == STATUS_ABORTED) break;
16801 if (data.devices_status == STATUS_QUIT) break;
16802
16803 if (data.devices_status == STATUS_BYPASS)
16804 {
16805 data.devices_status = STATUS_RUNNING;
16806 }
16807 }
16808
16809 // 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
16810
16811 if (attack_mode == ATTACK_MODE_STRAIGHT)
16812 {
16813 if (data.wordlist_mode == WL_MODE_FILE)
16814 {
16815 if (data.dictfile == NULL)
16816 {
16817 if (dictfiles != NULL)
16818 {
16819 data.dictfile = dictfiles[0];
16820
16821 hc_timer_set (&data.timer_running);
16822 }
16823 }
16824 }
16825 }
16826 // NOTE: combi is okay because it is already set beforehand
16827 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16828 {
16829 if (data.dictfile == NULL)
16830 {
16831 if (dictfiles != NULL)
16832 {
16833 hc_timer_set (&data.timer_running);
16834
16835 data.dictfile = dictfiles[0];
16836 }
16837 }
16838 }
16839 else if (attack_mode == ATTACK_MODE_BF)
16840 {
16841 if (data.mask == NULL)
16842 {
16843 hc_timer_set (&data.timer_running);
16844
16845 data.mask = masks[0];
16846 }
16847 }
16848
16849 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16850 {
16851 data.devices_status = STATUS_EXHAUSTED;
16852 }
16853
16854 // if cracked / aborted remove last induction dictionary
16855
16856 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16857 {
16858 struct stat induct_stat;
16859
16860 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16861 {
16862 unlink (induction_dictionaries[file_pos]);
16863 }
16864 }
16865
16866 // wait for non-interactive threads
16867
16868 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16869 {
16870 hc_thread_wait (1, &ni_threads[thread_idx]);
16871 }
16872
16873 local_free (ni_threads);
16874
16875 // wait for interactive threads
16876
16877 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16878 {
16879 hc_thread_wait (1, &i_thread);
16880 }
16881
16882 // we dont need restore file anymore
16883 if (data.restore_disable == 0)
16884 {
16885 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16886 {
16887 unlink (eff_restore_file);
16888 unlink (new_restore_file);
16889 }
16890 else
16891 {
16892 cycle_restore ();
16893 }
16894 }
16895
16896 // finally save left hashes
16897
16898 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16899 {
16900 save_hash ();
16901 }
16902
16903 /**
16904 * Clean up
16905 */
16906
16907 if (benchmark == 1)
16908 {
16909 status_benchmark ();
16910
16911 log_info ("");
16912 }
16913 else
16914 {
16915 if (quiet == 0) clear_prompt ();
16916
16917 if (quiet == 0) log_info ("");
16918
16919 if (status == 1)
16920 {
16921 status_display ();
16922 }
16923 else
16924 {
16925 if (quiet == 0) status_display ();
16926 }
16927
16928 if (quiet == 0) log_info ("");
16929 }
16930
16931 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16932 {
16933 hc_device_param_t *device_param = &data.devices_param[device_id];
16934
16935 if (device_param->skipped) continue;
16936
16937 local_free (device_param->result);
16938
16939 local_free (device_param->combs_buf);
16940
16941 local_free (device_param->hooks_buf);
16942
16943 local_free (device_param->device_name);
16944
16945 local_free (device_param->device_name_chksum);
16946
16947 local_free (device_param->device_version);
16948
16949 local_free (device_param->driver_version);
16950
16951 if (device_param->pws_buf) myfree (device_param->pws_buf);
16952 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16953 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16954 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16955 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16956 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16957 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16958 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16959 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16960 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16961 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16962 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16963 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16964 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16965 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16966 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16967 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16968 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16969 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16970 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16971 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16972 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16973 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16974 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16975 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16976 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16977 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16978 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16979 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16980
16981 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16982 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16983 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16984 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16985 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16986 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16987 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16988 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16989 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16990 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16991
16992 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16993 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16994 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16995
16996 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16997 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16998 }
16999
17000 // reset default fan speed
17001
17002 #ifdef HAVE_HWMON
17003 if (gpu_temp_disable == 0)
17004 {
17005 #ifdef HAVE_ADL
17006 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17007 {
17008 hc_thread_mutex_lock (mux_adl);
17009
17010 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17011 {
17012 hc_device_param_t *device_param = &data.devices_param[device_id];
17013
17014 if (device_param->skipped) continue;
17015
17016 if (data.hm_device[device_id].fan_supported == 1)
17017 {
17018 int fanspeed = temp_retain_fanspeed_value[device_id];
17019
17020 if (fanspeed == -1) continue;
17021
17022 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17023
17024 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17025 }
17026 }
17027
17028 hc_thread_mutex_unlock (mux_adl);
17029 }
17030 #endif // HAVE_ADL
17031 }
17032
17033 #ifdef HAVE_ADL
17034 // reset power tuning
17035
17036 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17037 {
17038 hc_thread_mutex_lock (mux_adl);
17039
17040 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17041 {
17042 hc_device_param_t *device_param = &data.devices_param[device_id];
17043
17044 if (device_param->skipped) continue;
17045
17046 if (data.hm_device[device_id].od_version == 6)
17047 {
17048 // check powertune capabilities first, if not available then skip device
17049
17050 int powertune_supported = 0;
17051
17052 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17053 {
17054 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17055
17056 return (-1);
17057 }
17058
17059 if (powertune_supported != 0)
17060 {
17061 // powercontrol settings
17062
17063 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)
17064 {
17065 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17066
17067 return (-1);
17068 }
17069
17070 // clocks
17071
17072 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17073
17074 performance_state->iNumberOfPerformanceLevels = 2;
17075
17076 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17077 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17078 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17079 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17080
17081 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)
17082 {
17083 log_info ("ERROR: Failed to restore ADL performance state");
17084
17085 return (-1);
17086 }
17087
17088 local_free (performance_state);
17089 }
17090 }
17091 }
17092
17093 hc_thread_mutex_unlock (mux_adl);
17094 }
17095 #endif // HAVE_ADL
17096
17097 if (gpu_temp_disable == 0)
17098 {
17099 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17100 if (data.hm_nv)
17101 {
17102 #if defined(LINUX) && defined(HAVE_NVML)
17103
17104 hm_NVML_nvmlShutdown (data.hm_nv);
17105
17106 nvml_close (data.hm_nv);
17107
17108 #elif defined(WIN) && (HAVE_NVAPI)
17109
17110 hm_NvAPI_Unload (data.hm_nv);
17111
17112 nvapi_close (data.hm_nv);
17113
17114 #endif
17115
17116 data.hm_nv = NULL;
17117 }
17118 #endif
17119
17120 #ifdef HAVE_ADL
17121 if (data.hm_amd)
17122 {
17123 hm_ADL_Main_Control_Destroy (data.hm_amd);
17124
17125 adl_close (data.hm_amd);
17126 data.hm_amd = NULL;
17127 }
17128 #endif
17129 }
17130 #endif // HAVE_HWMON
17131
17132 // free memory
17133
17134 local_free (masks);
17135
17136 local_free (dictstat_base);
17137
17138 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17139 {
17140 pot_t *pot_ptr = &pot[pot_pos];
17141
17142 hash_t *hash = &pot_ptr->hash;
17143
17144 local_free (hash->digest);
17145
17146 if (isSalted)
17147 {
17148 local_free (hash->salt);
17149 }
17150 }
17151
17152 local_free (pot);
17153
17154 local_free (all_kernel_rules_cnt);
17155 local_free (all_kernel_rules_buf);
17156
17157 local_free (wl_data->buf);
17158 local_free (wl_data);
17159
17160 local_free (bitmap_s1_a);
17161 local_free (bitmap_s1_b);
17162 local_free (bitmap_s1_c);
17163 local_free (bitmap_s1_d);
17164 local_free (bitmap_s2_a);
17165 local_free (bitmap_s2_b);
17166 local_free (bitmap_s2_c);
17167 local_free (bitmap_s2_d);
17168
17169 #ifdef HAVE_HWMON
17170 local_free (temp_retain_fanspeed_value);
17171 #ifdef HAVE_ADL
17172 local_free (od_clock_mem_status);
17173 local_free (od_power_control_status);
17174 #endif // ADL
17175 #endif
17176
17177 global_free (devices_param);
17178
17179 global_free (kernel_rules_buf);
17180
17181 global_free (root_css_buf);
17182 global_free (markov_css_buf);
17183
17184 global_free (digests_buf);
17185 global_free (digests_shown);
17186 global_free (digests_shown_tmp);
17187
17188 global_free (salts_buf);
17189 global_free (salts_shown);
17190
17191 global_free (esalts_buf);
17192
17193 global_free (words_progress_done);
17194 global_free (words_progress_rejected);
17195 global_free (words_progress_restored);
17196
17197 if (pot_fp) fclose (pot_fp);
17198
17199 if (data.devices_status == STATUS_QUIT) break;
17200 }
17201
17202 // destroy others mutex
17203
17204 hc_thread_mutex_delete (mux_dispatcher);
17205 hc_thread_mutex_delete (mux_counter);
17206 hc_thread_mutex_delete (mux_display);
17207 hc_thread_mutex_delete (mux_adl);
17208
17209 // free memory
17210
17211 local_free (eff_restore_file);
17212 local_free (new_restore_file);
17213
17214 local_free (rd);
17215
17216 // tuning db
17217
17218 tuning_db_destroy (tuning_db);
17219
17220 // loopback
17221
17222 local_free (loopback_file);
17223
17224 if (loopback == 1) unlink (loopback_file);
17225
17226 // induction directory
17227
17228 if (induction_dir == NULL)
17229 {
17230 if (attack_mode != ATTACK_MODE_BF)
17231 {
17232 if (rmdir (induction_directory) == -1)
17233 {
17234 if (errno == ENOENT)
17235 {
17236 // good, we can ignore
17237 }
17238 else if (errno == ENOTEMPTY)
17239 {
17240 // good, we can ignore
17241 }
17242 else
17243 {
17244 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17245
17246 return (-1);
17247 }
17248 }
17249
17250 local_free (induction_directory);
17251 }
17252 }
17253
17254 // outfile-check directory
17255
17256 if (outfile_check_dir == NULL)
17257 {
17258 if (rmdir (outfile_check_directory) == -1)
17259 {
17260 if (errno == ENOENT)
17261 {
17262 // good, we can ignore
17263 }
17264 else if (errno == ENOTEMPTY)
17265 {
17266 // good, we can ignore
17267 }
17268 else
17269 {
17270 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17271
17272 return (-1);
17273 }
17274 }
17275
17276 local_free (outfile_check_directory);
17277 }
17278
17279 time_t proc_stop;
17280
17281 time (&proc_stop);
17282
17283 logfile_top_uint (proc_start);
17284 logfile_top_uint (proc_stop);
17285
17286 logfile_top_msg ("STOP");
17287
17288 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17289 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17290
17291 if (data.ocl) ocl_close (data.ocl);
17292
17293 if (data.devices_status == STATUS_ABORTED) return 2;
17294 if (data.devices_status == STATUS_QUIT) return 2;
17295 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17296 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17297 if (data.devices_status == STATUS_CRACKED) return 0;
17298
17299 return -1;
17300 }
Hashcat additions to support pwdhash